def __init__(
self,
config: ConfigContextCommon,
name: str = "",
thread: int = 0,
transitionms: int = 0,
retentionms: int = 0,
) -> None:
"""
Args:
config: A config object.
"""
logname = Path(__file__).stem
self._logger = logging.getLogger(f"{config.PACKAGE_NAME}.{logname}")
redis_host = os.environ.get("REDISHOST", "localhost")
redis_port = int(os.environ.get("REDISPORT", 6379))
self._rts = RedisTimeSeries(host=redis_host, port=redis_port)
self._name = name or getattr(config, "name", "A")
self._thread = thread or getattr(config, "thread", 0)
self._transitionms = transitionms or getattr(config, "transitionms",
100)
self._retentionms = retentionms or getattr(config, "retentionms",
7 * 24 * 60 * 60 * 1000)
self._previous_value = 0
def setUp(self):
global rts
global version
rts = RedisTimeSeries(port=port)
rts.redis.flushdb()
modules = rts.redis.execute_command("module", "list")
if modules is not None:
for module_info in modules:
if module_info[1] == b'timeseries':
version = int(module_info[3])
def testPool(self):
redis = Redis(port=port)
client = RedisTimeSeries(conn=redis, port=666)
name = 'test'
client.create(name)
self.assertEqual(None, client.get(name))
client.add(name, 2, 3)
self.assertEqual(2, client.get(name)[0])
info = client.info(name)
self.assertEqual(1, info.total_samples)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--redis-server",
help="redis server address",
default="localhost")
parser.add_argument("--redis-port",
help="redis server port",
default=6379,
type=int)
args = parser.parse_args()
print("""
Starting with:
redis server: {}
redis port: {}
""".format(args.redis_server, args.redis_port))
rts = RedisTimeSeries(port=args.redis_port, host=args.redis_server)
try:
rts.create('temperature',
retentionSecs=60 * 24,
labels={'sensorId': '2'})
except Exception as e:
# will except if key already exists (i.e. on restart)
print(str(e))
variance = 0
t = 0
while True:
# add with current timestamp
print(".", end="")
variance += (random.random() - 0.5) / 10.0
t += 1
value = math.cos(t / 100) + variance
rts.add('temperature', '*', value)
sleep(0.1)
def setUp(self):
global rts
rts = RedisTimeSeries(port=port)
rts.flushdb()
#!/usr/bin/env python
from redistimeseries.client import Client as RedisTimeSeries
import redis
import time
redis_host = "localhost"
redis_port = 6379
rts = RedisTimeSeries(host=redis_host, port=redis_port)
pool = redis.ConnectionPool(host=redis_host, port=redis_port)
r = redis.Redis(connection_pool=pool)
try:
r.xadd("mystream", {'event_type': 'startup', 'user': '******'})
r.xgroup_create("mystream", "consumerGroup", '$')
except:
print("group already exists")
while True:
msgs = r.xreadgroup("consumerGroup",
"consumerName",
streams={"mystream": '>'},
count=10,
block=1000,
noack=False)
for msg in msgs:
for m in msg[1]:
evnt = m[1]['event_type']
try:
# An example Python client for Redis key-value store using RedisTimeSeries.
from redistimeseries.client import Client as RedisTimeSeries
import time
import sys
import site
import datetime
import random
print(' \n '.join(sys.path))
ts = RedisTimeSeries(host='localhost', port=6379)
#ts.flushdb()
key = 'temperature'
def create(key):
print('\n Create new time series: %s' % str(key))
#ts.create(key,retentionSecs=30,labels={'sensor_id' : 2,'area_id' : 32})
ts.create(key,retention_msecs=30000,labels={'sensor_id' : 2,'area_id' : 32})
print('')
def store(key, interval):
print("\n Append new value to time series:\n")
begin_time = int(time.time())
import json
import time
import logging
import redis
from redistimeseries.client import Client as RedisTimeSeries
# Formulas to perform transforms on messages
import transformation_list as transforms
log = logging.getLogger()
# log.setLevel("INFO")
# Setup Redis and events of interest to track
r = redis.Redis(host="localhost", port=6379, db=0)
rts = RedisTimeSeries()
if not r.exists("vehicle_speed"):
rts.create("vehicle_speed",
retention_msecs=300000,
labels={"Time": "Series"})
if not r.exists("throttle_position"):
rts.create("throttle_position",
retention_msecs=300000,
labels={"Time": "Series"})
if not r.exists("ambient_air_temperature"):
rts.create("ambient_air_temperature",
retention_msecs=300000,
labels={"Time": "Series"})
# Track all messages on extract queue to only send every 1 second
msg_time_last_sent = {}
