def __init__(self, api_key, api_secret, interval=INTERVAL, keep_days=KEEP_DAYS): self.keep_days = datetime.timedelta(days=keep_days) self.interval = datetime.timedelta(hours=interval) self.client = Client(api_key, api_secret)
def push(self, database, series, value): """ Pushes a single value with current timestamp to the given database/series """ db = self._databases[database] client = Client(db['api_key'], db['api_secret']) data = [DataPoint(datetime.now(), float(value))] client.write_key(series, data)
def setUp(self): self.client = Client('key', 'secret', 'example.com', 443, True) self.client.session = mock.Mock() self.headers = { 'User-Agent': 'tempodb-python/%s' % tempodb.get_version(), 'Accept-Encoding': 'gzip', } self.get_headers = self.headers self.delete_headers = self.headers self.put_headers = dict({ 'Content-Type': 'application/json', }, **self.headers) self.post_headers = self.put_headers
def push(self, database, series, value): """ Pushes a single value with current timestamp to the given database/series """ try: db = self._databases[database] client = Client(db['api_key'], db['api_secret']) data = [DataPoint(datetime.now(), float(value))] client.write_key(series, data) self.last_response = 'OK' return True except Exception as e: self.last_response = e return False
class TempoDBOutput(Output): def __init__(self, **tempo_kwargs): self.client = Client(**tempo_kwargs) def __repr__(self): return '<%s>' % self.__class__.__name__ def send(self, key, value): if isinstance(value, bool): value = 1 if value else 0 self.client.write_key( key, [DataPoint(datetime.now(), value)] )
def import_samples(): sin = [math.sin(math.radians(d)) for d in range(0,3600)] cos = [math.cos(math.radians(d)) for d in range(0,3600)] sin_data = [] cos_data = [] start_time = datetime.datetime(2013,07,26) for i in range(len(sin)): current_time = start_time + datetime.timedelta(minutes=i) sin_data.append(DataPoint(current_time, sin[i])) cos_data.append(DataPoint(current_time, cos[i])) client = Client(API_KEY, API_SECRET) client.write_key('type:trig.function:sin.1',sin_data) client.write_key('type:trig.function:cos.1', cos_data)
def __init__(self, conf): TRUE_VALUES = set(('true', '1', 'yes', 'on', 't', 'y')) self.logger = logging.getLogger('statsdpy') self.logger.setLevel(logging.INFO) self.syslog = SysLogHandler() self.formatter = logging.Formatter('%(name)s: %(message)s') self.syslog.setFormatter(self.formatter) self.logger.addHandler(self.syslog) self.conf = conf self.graphite_host = conf.get('graphite_host', '127.0.0.1') self.graphite_port = int(conf.get('graphite_port', '2003')) self.listen_addr = conf.get('listen_addr', '127.0.0.1') self.listen_port = int(conf.get('listen_port', 8125)) self.debug = conf.get('debug', 'yes') in TRUE_VALUES self.combined_events = conf.get('combined_events', 'no') in TRUE_VALUES self.flush_interval = int(conf.get('flush_interval', 10)) self.pct_threshold = int(conf.get('percent_threshold', 90)) self.graphite_addr = (self.graphite_host, self.graphite_port) self.keycheck = re.compile(r'\s+|/|[^a-zA-Z_\-0-9\.]') self.ratecheck = re.compile('^@([\d\.]+)') self.counters = {} self.timers = {} self.stats_seen = 0 self.tempodb_enabled = conf.get('tempodb_enabled', 'false') in TRUE_VALUES self.tempodb_key = conf.get('tempodb_key', '') self.tempodb_secret = conf.get('tempodb_secret', '') self.tempodb_host = conf.get('tempodb_host', 'localhost') self.tempodb_port = int(conf.get('tempodb_port', 443)) self.tempodb_secure = conf.get('tempodb_secure', "true") in TRUE_VALUES self.tempodb_client = TempoDBClient(self.tempodb_key, self.tempodb_secret, \ self.tempodb_host, self.tempodb_port, \ self.tempodb_secure)
def test_init(self): client = Client('key', 'secret', 'example.com', 80, False) self.assertEqual(client.key, 'key') self.assertEqual(client.secret, 'secret') self.assertEqual(client.host, 'example.com') self.assertEqual(client.port, 80) self.assertEqual(client.secure, False)
def read_samples(): client = Client(API_KEY, API_SECRET) start_time = datetime.datetime(2013,07,26) end_time = start_time + datetime.timedelta(minutes=3600) dataset = client.read_key('type:trig.function:sin.1', start_time, end_time, interval="1min") print "Average of sin", round(dataset.summary.mean) print "Max of sin", dataset.summary.max attributes={ "function": "sin" } datasets = client.read(start_time, end_time, attributes=attributes) for dset in datasets: print "Average of %s" % dset.series.attributes['function'], round(dset.summary.mean) attrs={'type':'trig'} datasets = client.read(start_time, end_time, attributes=attrs) for dset in datasets: print "Average of %s" % dset.series.attributes['function'], round(dset.summary.mean)
""" http://tempo-db.com/api/write-series/#write-series-by-key """ from datetime import datetime, timedelta import random from tempodb import Client, DataPoint client = Client('a93feb1d6a7e49919331b09eab299967', '67fd4ee803df456b845cdeb5e675d465') # for id in range(1,33): # station='station_'+str(id) # series = client.create_series(station) date = datetime(2012, 1, 1) for day in range(1, 10): # print out the current day we are sending data for print date for id in range(1,33): data = [] # 1440 minutes in one day for min in range (1, 1441): data.append(DataPoint(date, random.random() * 50.0)) date = date + timedelta(minutes=1) station='station_'+str(id) client.write_key(station, data)
""" http://tempo-db.com/api/write-series/#write-series-by-key """ import datetime import random from tempodb import Client, DataPoint client = Client('your-api-key', 'your-api-secret') date = datetime.datetime(2012, 1, 1) for day in range(1, 10): # print out the current day we are sending data for print date data = [] # 1440 minutes in one day for min in range(1, 1441): data.append(DataPoint(date, random.random() * 50.0)) date = date + datetime.timedelta(minutes=1) client.write_key('your-custom-key', data)
def test_port_defaults(self): """ 80 is the default port for HTTP, 443 is the default for HTTPS """ client = Client('key', 'secret', 'example.com', 80, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com/v1/etc') client = Client('key', 'secret', 'example.com', 88, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com:88/v1/etc') client = Client('key', 'secret', 'example.com', 443, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com:443/v1/etc') client = Client('key', 'secret', 'example.com', 443, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com/v1/etc') client = Client('key', 'secret', 'example.com', 88, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com:88/v1/etc') client = Client('key', 'secret', 'example.com', 80, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com:80/v1/etc')
class ClientTest(TestCase): def setUp(self): self.client = Client('key', 'secret', 'example.com', 443, True) self.client.session = mock.Mock() self.headers = { 'User-Agent': 'tempodb-python/%s' % tempodb.get_version(), 'Accept-Encoding': 'gzip', } self.get_headers = self.headers self.delete_headers = self.headers self.put_headers = dict({ 'Content-Type': 'application/json', }, **self.headers) self.post_headers = self.put_headers def test_init(self): client = Client('key', 'secret', 'example.com', 80, False) self.assertEqual(client.key, 'key') self.assertEqual(client.secret, 'secret') self.assertEqual(client.host, 'example.com') self.assertEqual(client.port, 80) self.assertEqual(client.secure, False) def test_defaults(self): client = Client('key', 'secret') self.assertEqual(client.host, 'api.tempo-db.com') self.assertEqual(client.port, 443) self.assertEqual(client.secure, True) def test_port_defaults(self): """ 80 is the default port for HTTP, 443 is the default for HTTPS """ client = Client('key', 'secret', 'example.com', 80, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com/v1/etc') client = Client('key', 'secret', 'example.com', 88, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com:88/v1/etc') client = Client('key', 'secret', 'example.com', 443, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com:443/v1/etc') client = Client('key', 'secret', 'example.com', 443, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com/v1/etc') client = Client('key', 'secret', 'example.com', 88, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com:88/v1/etc') client = Client('key', 'secret', 'example.com', 80, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com:80/v1/etc') def test_get_series(self): self.client.session.get.return_value = MockResponse(200, """[{ "id": "id", "key": "key", "name": "name", "tags": ["tag1", "tag2"], "attributes": {"key1": "value1"} }]""") series = self.client.get_series() self.client.session.get.assert_called_once_with( 'https://example.com/v1/series/', auth=('key', 'secret'), headers=self.get_headers ) expected = [Series('id', 'key', 'name', {'key1': 'value1'}, ['tag1', 'tag2'])] self.assertEqual(series, expected) def test_create_series(self): self.client.session.post.return_value = MockResponse(200, """{ "id": "id", "key": "my-key.tag1.1", "name": "", "tags": ["my-key", "tag1"], "attributes": {} }""") series = self.client.create_series("my-key.tag1.1") self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/', data="""{"key": "my-key.tag1.1"}""", auth=('key', 'secret'), headers=self.post_headers ) expected = Series('id', 'my-key.tag1.1', '', {}, ['my-key', 'tag1']) self.assertEqual(series, expected) def test_create_series_validity_error(self): with self.assertRaises(ValueError): series = self.client.create_series('key.b%^.test') def test_update_series(self): update = Series('id', 'key', 'name', {'key1': 'value1'}, ['tag1']) self.client.session.put.return_value = MockResponse(200, simplejson.dumps(update.to_json())) updated = self.client.update_series(update) self.client.session.put.assert_called_once_with( 'https://example.com/v1/series/id/id/', auth=('key', 'secret'), data=simplejson.dumps(update.to_json()), headers=self.put_headers ) self.assertEqual(update, updated) def test_read_id(self): self.client.session.get.return_value = MockResponse(200, """{ "series": { "id": "id", "key": "key", "name": "", "tags": [], "attributes": {} }, "start": "2012-03-27T00:00:00.000", "end": "2012-03-28T00:00:00.000", "data": [{"t": "2012-03-27T00:00:00.000", "v": 12.34}], "summary": {} }""") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) dataset = self.client.read_id('id', start, end) expected = DataSet(Series('id', 'key'), start, end, [DataPoint(start, 12.34)], Summary()) self.client.session.get.assert_called_once_with( 'https://example.com/v1/series/id/id/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.get_headers ) self.assertEqual(dataset, expected) def test_read_key(self): self.client.session.get.return_value = MockResponse(200, """{ "series": { "id": "id", "key": "key1", "name": "", "tags": [], "attributes": {} }, "start": "2012-03-27T00:00:00.000", "end": "2012-03-28T00:00:00.000", "data": [{"t": "2012-03-27T00:00:00.000", "v": 12.34}], "summary": {} }""") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) dataset = self.client.read_key('key1', start, end) expected = DataSet(Series('id', 'key1'), start, end, [DataPoint(start, 12.34)], Summary()) self.client.session.get.assert_called_once_with( 'https://example.com/v1/series/key/key1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.get_headers ) self.assertEqual(dataset, expected) def test_read_key_escape(self): self.client.session.get.return_value = MockResponse(200, """{ "series": { "id": "id", "key": "ke:y/1", "name": "", "tags": [], "attributes": {} }, "start": "2012-03-27T00:00:00.000", "end": "2012-03-28T00:00:00.000", "data": [{"t": "2012-03-27T00:00:00.000", "v": 12.34}], "summary": {} }""") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) dataset = self.client.read_key('ke:y/1', start, end) expected = DataSet(Series('id', 'ke:y/1'), start, end, [DataPoint(start, 12.34)], Summary()) self.client.session.get.assert_called_once_with( 'https://example.com/v1/series/key/ke%3Ay%2F1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.get_headers ) self.assertEqual(dataset, expected) def test_read(self): self.client.session.get.return_value = MockResponse(200, """[{ "series": { "id": "id", "key": "key1", "name": "", "tags": [], "attributes": {} }, "start": "2012-03-27T00:00:00.000", "end": "2012-03-28T00:00:00.000", "data": [{"t": "2012-03-27T00:00:00.000", "v": 12.34}], "summary": {} }]""") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) datasets = self.client.read(start, end, keys=['key1']) expected = [DataSet(Series('id', 'key1'), start, end, [DataPoint(start, 12.34)], Summary())] self.client.session.get.assert_called_once_with( 'https://example.com/v1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00&key=key1', auth=('key', 'secret'), headers=self.get_headers ) self.assertEqual(datasets, expected) def test_delete_id(self): self.client.session.delete.return_value = MockResponse(200, "") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) result = self.client.delete_id("id1", start, end) self.client.session.delete.assert_called_once_with( 'https://example.com/v1/series/id/id1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.delete_headers ) self.assertEquals(result, '') def test_delete_key(self): self.client.session.delete.return_value = MockResponse(200, "") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) result = self.client.delete_key("key1", start, end) self.client.session.delete.assert_called_once_with( 'https://example.com/v1/series/key/key1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.delete_headers ) self.assertEquals(result, '') def test_delete_key_escape(self): self.client.session.delete.return_value = MockResponse(200, "") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) result = self.client.delete_key("ke:y/1", start, end) self.client.session.delete.assert_called_once_with( 'https://example.com/v1/series/key/ke%3Ay%2F1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.delete_headers ) self.assertEquals(result, '') def test_write_id(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 12.34)] result = self.client.write_id("id1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/id/id1/data/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 12.34}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_write_key(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 12.34)] result = self.client.write_key("key1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/key/key1/data/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 12.34}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_write_key_escape(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 12.34)] result = self.client.write_key("ke:y/1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/key/ke%3Ay%2F1/data/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 12.34}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_increment_id(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 1)] result = self.client.increment_id("id1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/id/id1/increment/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 1}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_increment_key(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 1)] result = self.client.increment_key("key1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/key/key1/increment/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 1}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_increment_key_escape(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 1)] result = self.client.increment_key("ke:y/1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/key/ke%3Ay%2F1/increment/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 1}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_write_bulk(self): self.client.session.post.return_value = MockResponse(200, "") data = [ { 'id': '01868c1a2aaf416ea6cd8edd65e7a4b8', 'v': 4.164 }, { 'id': '38268c3b231f1266a392931e15e99231', 'v': 73.13 }, { 'key': 'your-custom-key', 'v': 55.423 }, { 'key': 'foo', 'v': 324.991 }, ] ts = datetime.datetime(2012, 3, 27) result = self.client.write_bulk(ts, data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/data/', auth=('key', 'secret'), data="""{"data": %s, "t": "2012-03-27T00:00:00"}""" % simplejson.dumps(data), headers=self.post_headers ) self.assertEqual(result, '') def test_increment_bulk(self): self.client.session.post.return_value = MockResponse(200, "") data = [ { 'id': '01868c1a2aaf416ea6cd8edd65e7a4b8', 'v': 4 }, { 'id': '38268c3b231f1266a392931e15e99231', 'v': 2 }, { 'key': 'your-custom-key', 'v': 1 }, { 'key': 'foo', 'v': 1 }, ] ts = datetime.datetime(2012, 3, 27) result = self.client.increment_bulk(ts, data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/increment/', auth=('key', 'secret'), data="""{"data": %s, "t": "2012-03-27T00:00:00"}""" % simplejson.dumps(data), headers=self.post_headers ) self.assertEqual(result, '')
from datetime import datetime from time import sleep import random from tempodb import Client, DataPoint import tempodb from os import getenv API_KEY = getenv('API_KEY') assert API_KEY, "API_KEY is required" API_SECRET = getenv('API_SECRET') assert API_SECRET, "API_SECRET is required" SERIES_KEY = getenv('SERIES_KEY', 'prng') API_HOST = getenv('API_HOST', tempodb.client.API_HOST) API_PORT = int(getenv('API_PORT', tempodb.client.API_PORT)) API_SECURE = bool(getenv('API_SECURE', True)) client = Client(API_KEY, API_SECRET, API_HOST, API_PORT, API_SECURE) while True: client.write_key(SERIES_KEY, [DataPoint(datetime.now(), random.random() * 50.0)]) sleep(1)
class TempoDBArchive(object): def __init__(self, api_key, api_secret, interval=INTERVAL, keep_days=KEEP_DAYS): self.keep_days = datetime.timedelta(days=keep_days) self.interval = datetime.timedelta(hours=interval) self.client = Client(api_key, api_secret) def get_series_keys(self): try: return self._series_keys except AttributeError: self._series_keys = [p.key for p in self.client.get_series()] return self._series_keys def get_datapoints(self, series_key, delete=False): ts = datetime.datetime.utcnow() end = datetime.datetime(ts.year, ts.month, ts.day) - self.keep_days while True: start = end - self.interval data = self.client.read_key(series_key, start, end, tz='UTC') yield data.data if not data.data: break if delete: self.client.delete_key(series_key, start, end) end = start def write_sqlite(self, series_key, data, filename=DEFAULT_DATABASE_NAME): conn = sqlite3.connect(filename) cur = conn.cursor() # I know this might possibly run untrusted code but I'm not aware of # a built-in method for escaping identifiers and this is just an # archive tool. query = '''CREATE TABLE IF NOT EXISTS "{0}" ( timestamp text UNIQUE NOT NULL, value real NOT NULL)'''.format(series_key) cur.execute(query) query = 'INSERT INTO "{0}" values (?, ?)'.format(series_key) with conn: [ cur.execute(query, (str(reading.ts), reading.value)) for reading in data ] conn.close() def archive(self, series=None, delete=False): if series in (None, []): series_keys = self.get_series_keys() elif isinstance(series, str): series_keys = (series, ) else: series_keys = series for key in series_keys: if key not in self.get_series_keys(): print('Series {0} does not exist'.format(key)) continue self.archive_series(key, delete) def archive_series(self, series_key, delete=False): start = datetime.datetime.utcnow() - self.keep_days start_date = datetime.datetime(start.year, start.month, start.day) for day, data in enumerate(self.get_datapoints(series_key, delete), 1): delta = self.interval * day archive_date = (start_date - delta).strftime("%Y-%m-%d") print('Archiving {0} for day {1}'.format(series_key, archive_date)) try: self.write_sqlite(series_key, data) except sqlite3.IntegrityError: print('Skipping', archive_date)
class ClientTest(TestCase): def setUp(self): self.client = Client('key', 'secret', 'example.com', 443, True) self.client.session = mock.Mock() self.headers = { 'User-Agent': 'tempodb-python/%s' % tempodb.get_version(), 'Accept-Encoding': 'gzip', } self.get_headers = self.headers self.delete_headers = self.headers self.put_headers = dict({ 'Content-Type': 'application/json', }, **self.headers) self.post_headers = self.put_headers def test_init(self): client = Client('key', 'secret', 'example.com', 80, False) self.assertEqual(client.key, 'key') self.assertEqual(client.secret, 'secret') self.assertEqual(client.host, 'example.com') self.assertEqual(client.port, 80) self.assertEqual(client.secure, False) def test_defaults(self): client = Client('key', 'secret') self.assertEqual(client.host, 'api.tempo-db.com') self.assertEqual(client.port, 443) self.assertEqual(client.secure, True) def test_port_defaults(self): """ 80 is the default port for HTTP, 443 is the default for HTTPS """ client = Client('key', 'secret', 'example.com', 80, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com/v1/etc') client = Client('key', 'secret', 'example.com', 88, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com:88/v1/etc') client = Client('key', 'secret', 'example.com', 443, False) self.assertEqual(client.build_full_url('/etc'), 'http://example.com:443/v1/etc') client = Client('key', 'secret', 'example.com', 443, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com/v1/etc') client = Client('key', 'secret', 'example.com', 88, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com:88/v1/etc') client = Client('key', 'secret', 'example.com', 80, True) self.assertEqual(client.build_full_url('/etc'), 'https://example.com:80/v1/etc') def test_get_series(self): self.client.session.get.return_value = MockResponse(200, """[{ "id": "id", "key": "key", "name": "name", "tags": ["tag1", "tag2"], "attributes": {"key1": "value1"} }]""") series = self.client.get_series() self.client.session.get.assert_called_once_with( 'https://example.com/v1/series/', auth=('key', 'secret'), headers=self.get_headers ) expected = [ Series('id', 'key', 'name', {'key1': 'value1'}, ['tag1', 'tag2'])] self.assertEqual(series, expected) def test_delete_series(self): self.client.session.delete.return_value = MockResponse( 200, """{"deleted":2}""") summary = self.client.delete_series( [], [], [], {'key': 'one', 'key2': 'two'}) self.assertEqual(summary.deleted, 2) def test_create_series(self): self.client.session.post.return_value = MockResponse(200, """{ "id": "id", "key": "my-key.tag1.1", "name": "", "tags": ["my-key", "tag1"], "attributes": {} }""") series = self.client.create_series("my-key.tag1.1") self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/', data="""{"key": "my-key.tag1.1"}""", auth=('key', 'secret'), headers=self.post_headers ) expected = Series('id', 'my-key.tag1.1', '', {}, ['my-key', 'tag1']) self.assertEqual(series, expected) def test_create_series_validity_error(self): with self.assertRaises(ValueError): series = self.client.create_series('key.b%^.test') def test_update_series(self): update = Series('id', 'key', 'name', {'key1': 'value1'}, ['tag1']) self.client.session.put.return_value = MockResponse( 200, simplejson.dumps(update.to_json())) updated = self.client.update_series(update) self.client.session.put.assert_called_once_with( 'https://example.com/v1/series/id/id/', auth=('key', 'secret'), data=simplejson.dumps(update.to_json()), headers=self.put_headers ) self.assertEqual(update, updated) def test_read_id(self): self.client.session.get.return_value = MockResponse(200, """{ "series": { "id": "id", "key": "key", "name": "", "tags": [], "attributes": {} }, "start": "2012-03-27T00:00:00.000Z", "end": "2012-03-28T00:00:00.000Z", "data": [{"t": "2012-03-27T00:00:00.000Z", "v": 12.34}], "summary": {} }""") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) dataset = self.client.read_id('id', start, end) expected = DataSet(Series('id', 'key'), start, end, [DataPoint(start, 12.34)], Summary()) self.client.session.get.assert_called_once_with( 'https://example.com/v1/series/id/id/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.get_headers ) self.assertEqual(dataset, expected) def test_read_key(self): self.client.session.get.return_value = MockResponse(200, """{ "series": { "id": "id", "key": "key1", "name": "", "tags": [], "attributes": {} }, "start": "2012-03-27T00:00:00.000Z", "end": "2012-03-28T00:00:00.000Z", "data": [{"t": "2012-03-27T00:00:00.000Z", "v": 12.34}], "summary": {} }""") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) dataset = self.client.read_key('key1', start, end) expected = DataSet(Series('id', 'key1'), start, end, [DataPoint(start, 12.34)], Summary()) self.client.session.get.assert_called_once_with( 'https://example.com/v1/series/key/key1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.get_headers ) self.assertEqual(dataset, expected) def test_read_key_escape(self): self.client.session.get.return_value = MockResponse(200, """{ "series": { "id": "id", "key": "ke:y/1", "name": "", "tags": [], "attributes": {} }, "start": "2012-03-27T00:00:00.000Z", "end": "2012-03-28T00:00:00.000Z", "data": [{"t": "2012-03-27T00:00:00.000Z", "v": 12.34}], "summary": {} }""") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) dataset = self.client.read_key('ke:y/1', start, end) expected = DataSet(Series('id', 'ke:y/1'), start, end, [DataPoint(start, 12.34)], Summary()) self.client.session.get.assert_called_once_with( 'https://example.com/v1/series/key/ke%3Ay%2F1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.get_headers ) self.assertEqual(dataset, expected) def test_read(self): self.client.session.get.return_value = MockResponse(200, """[{ "series": { "id": "id", "key": "key1", "name": "", "tags": [], "attributes": {} }, "start": "2012-03-27T00:00:00.000Z", "end": "2012-03-28T00:00:00.000Z", "data": [{"t": "2012-03-27T00:00:00.000Z", "v": 12.34}], "summary": {} }]""") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) datasets = self.client.read(start, end, keys=['key1']) expected = [ DataSet(Series('id', 'key1'), start, end, [DataPoint(start, 12.34)], Summary())] self.client.session.get.assert_called_once_with( 'https://example.com/v1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00&key=key1', auth=('key', 'secret'), headers=self.get_headers ) self.assertEqual(datasets, expected) def test_delete_id(self): self.client.session.delete.return_value = MockResponse(200, "") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) result = self.client.delete_id("id1", start, end) self.client.session.delete.assert_called_once_with( 'https://example.com/v1/series/id/id1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.delete_headers ) self.assertEquals(result, '') def test_delete_key(self): self.client.session.delete.return_value = MockResponse(200, "") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) result = self.client.delete_key("key1", start, end) self.client.session.delete.assert_called_once_with( 'https://example.com/v1/series/key/key1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.delete_headers ) self.assertEquals(result, '') def test_delete_key_escape(self): self.client.session.delete.return_value = MockResponse(200, "") start = datetime.datetime(2012, 3, 27) end = datetime.datetime(2012, 3, 28) result = self.client.delete_key("ke:y/1", start, end) self.client.session.delete.assert_called_once_with( 'https://example.com/v1/series/key/ke%3Ay%2F1/data/?start=2012-03-27T00%3A00%3A00&end=2012-03-28T00%3A00%3A00', auth=('key', 'secret'), headers=self.delete_headers ) self.assertEquals(result, '') def test_write_id(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 12.34)] result = self.client.write_id("id1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/id/id1/data/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 12.34}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_write_key(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 12.34)] result = self.client.write_key("key1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/key/key1/data/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 12.34}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_write_key_escape(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 12.34)] result = self.client.write_key("ke:y/1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/key/ke%3Ay%2F1/data/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 12.34}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_increment_id(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 1)] result = self.client.increment_id("id1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/id/id1/increment/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 1}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_increment_key(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 1)] result = self.client.increment_key("key1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/key/key1/increment/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 1}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_increment_key_escape(self): self.client.session.post.return_value = MockResponse(200, "") data = [DataPoint(datetime.datetime(2012, 3, 27), 1)] result = self.client.increment_key("ke:y/1", data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/series/key/ke%3Ay%2F1/increment/', auth=('key', 'secret'), data="""[{"t": "2012-03-27T00:00:00", "v": 1}]""", headers=self.post_headers ) self.assertEquals(result, '') def test_write_bulk(self): self.client.session.post.return_value = MockResponse(200, "") data = [ {'id': '01868c1a2aaf416ea6cd8edd65e7a4b8', 'v': 4.164}, {'id': '38268c3b231f1266a392931e15e99231', 'v': 73.13}, {'key': 'your-custom-key', 'v': 55.423}, {'key': 'foo', 'v': 324.991}, ] ts = datetime.datetime(2012, 3, 27) result = self.client.write_bulk(ts, data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/data/', auth=('key', 'secret'), data="""{"data": %s, "t": "2012-03-27T00:00:00"}""" % simplejson.dumps(data), headers=self.post_headers ) self.assertEqual(result, '') def test_increment_bulk(self): self.client.session.post.return_value = MockResponse(200, "") data = [ {'id': '01868c1a2aaf416ea6cd8edd65e7a4b8', 'v': 4}, {'id': '38268c3b231f1266a392931e15e99231', 'v': 2}, {'key': 'your-custom-key', 'v': 1}, {'key': 'foo', 'v': 1}, ] ts = datetime.datetime(2012, 3, 27) result = self.client.increment_bulk(ts, data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/increment/', auth=('key', 'secret'), data="""{"data": %s, "t": "2012-03-27T00:00:00"}""" % simplejson.dumps(data), headers=self.post_headers ) self.assertEqual(result, '') def test_write_multi(self): self.client.session.post.return_value = MockResponse(200, "") data = [ {'t': datetime.datetime(2013, 8, 21), 'id': '01868c1a2aaf416ea6cd8edd65e7a4b8', 'v': 4.164}, {'t': datetime.datetime(2013, 8, 22), 'id': '38268c3b231f1266a392931e15e99231', 'v': 73.13}, {'t': datetime.datetime(2013, 8, 23), 'key': 'your-custom-key', 'v': 55.423}, {'t': datetime.datetime(2013, 8, 24), 'key': 'foo', 'v': 324.991}, ] result = self.client.write_multi(data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/multi/', auth=('key', 'secret'), data=simplejson.dumps(data, default=tempodb.DATETIME_HANDLER), headers=self.post_headers ) self.assertEqual(result, '') def test_write_multi_207(self): expected_response = """{ "{'error': {"multistatus": [ { "status": "422", "messages": [ "Must provide a series ID or key" ] }, { "status": "200", "messages": [] }, { "status": "422", "messages": [ "Must provide a numeric value", "Must provide a series ID or key" ] } ]}}""" self.client.session.post.return_value = MockResponse( 207, expected_response) data = [ {'t': datetime.datetime(2013, 8, 21), 'v': 4.164}, {'t': datetime.datetime(2013, 8, 22), 'id': '38268c3b231f1266a392931e15e99231'}, {} ] result = self.client.write_multi(data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/multi/', auth=('key', 'secret'), data=simplejson.dumps(data, default=tempodb.DATETIME_HANDLER), headers=self.post_headers ) self.assertEqual(result["error"], expected_response) def test_write_multi(self): self.client.session.post.return_value = MockResponse(200, "") data = [ {'t': datetime.datetime(2013, 8, 21), 'id': '01868c1a2aaf416ea6cd8edd65e7a4b8', 'v': 4164}, {'t': datetime.datetime(2013, 8, 22), 'id': '38268c3b231f1266a392931e15e99231', 'v': 7313}, {'t': datetime.datetime(2013, 8, 23), 'key': 'your-custom-key', 'v': 55423}, {'t': datetime.datetime(2013, 8, 24), 'key': 'foo', 'v': 324991}, ] result = self.client.write_multi(data) self.client.session.post.assert_called_once_with( 'https://example.com/v1/multi/', auth=('key', 'secret'), data=simplejson.dumps(data, default=tempodb.DATETIME_HANDLER), headers=self.post_headers ) self.assertEqual(result, '')
def __init__(self, **tempo_kwargs): self.client = Client(**tempo_kwargs)
""" http://tempo-db.com/api/write-series/#bulk-write-multiple-series """ import datetime from tempodb import Client client = Client('your-api-key', 'your-api-secret') bulk = { 't': datetime.datetime.now().isoformat(), 'data': [ { 'key': 'custom-series-key1', 'v': 1.11 }, { 'key': 'custom-series-key2', 'v': 2.22 }, { 'key': 'custom-series-key3', 'v': 3.33 }, { 'key': 'custom-series-key4', 'v': 4.44 }, ], }
""" http://tempo-db.com/api/read-series/#read-series-by-key """ import datetime from tempodb import Client # Modify these with your settings found at: http://tempo-db.com/manage/ API_KEY = '680d1adbbb0c42a398b5846c8e1517dd' API_SECRET = 'f2db65d178634a36b4c25467f8bc2099' SERIES_KEY = 'your-custom-key' client = Client(API_KEY, API_SECRET) start = datetime.date(2012, 1, 1) end = start + datetime.timedelta(days=1) data = client.read_key(SERIES_KEY, start, end) for datapoint in data.data: print datapoint
import math, datetime from tempodb import Client, DataPoint client = Client("a755539a9e124278b04f988d39bc5ef9", "43f97dc4dbbc46499bd6694a3455210c") sin = [math.sin(math.radians(d)) for d in range(0,3600)] cos = [math.cos(math.radians(d)) for d in range(0,3600)] start = datetime.datetime(2013,01,01) sin_data = [] cos_data = [] for i in range(len(sin)): sin_data.append(DataPoint(start + datetime.timedelta(minutes=i), sin[i])) cos_data.append(DataPoint(start + datetime.timedelta(minutes=i), cos[i])) client.write_key('type:sin.1',sin_data) client.write_key('type:cos.1', cos_data) client.read_key('type:sin.1', start, datetime.datetime(2013,01,05)) attributes={ "type": "sin" } client.read(start, datetime.datetime(2013,01,05), attributes= attributes)
import datetime, time from tempodb import Client, DataPoint from Temperature import Temperature from config import USER, PWD, API_KEY, API_SECRET UPDATE_INTERVAL = 60 # seconds tempoDB = Client(API_KEY, API_SECRET) core = Temperature(USER, PWD, 'mutant_jetpack') core.setInterval(UPDATE_INTERVAL) core.setRGB(0) print core while core.isConnected(): tempc = core.temperature() date = datetime.datetime.utcnow() if tempc: tempoDB.write_key("TEMPERATURE", [DataPoint(date, tempc)]) print "%s, %1.2f" % (datetime.datetime.now(), tempc) time.sleep(UPDATE_INTERVAL)
import pygal import datetime import json from tempodb import Client from pygal.style import BlueStyle API_KEY = 'API_KEY' API_SECRET = 'API_SECRET' MILES_SERIES_KEY = 'divvy.trip.miles' client = Client(API_KEY, API_SECRET) start = datetime.date(2013, 6, 27) end = start + datetime.timedelta(days=187) data = client.read_key(MILES_SERIES_KEY, start, end, interval="1day", function="sum") data_list = [] x_label_list = [] x_label_major_list = [] data_count=0 for datapoint in data.data: if data_count%15==0: x_label_major_list.append(datapoint.ts.strftime("%b %e, %Y")) x_label_list.append(datapoint.ts.strftime("%b %e, %Y")) data_list.append(datapoint.value) data_count = data_count + 1 chart = pygal.Bar(x_label_rotation=40,interpolate='cubic',show_minor_x_labels=False,disable_xml_declaration=True,explicit_size=True,style=BlueStyle)
""" http://tempo-db.com/api/write-series/#write-series-by-key """ import datetime import random from tempodb import Client, DataPoint # Modify these with your credentials found at: http://tempo-db.com/manage/ API_KEY = 'a68ffbe8f6fe4fb3bbda2782002680f0' API_SECRET = '3fe37f49b1bb4ae481dec13932c9bb92' SERIES_KEY = 'paul-python-1' client = Client(API_KEY, API_SECRET) date = datetime.datetime(2012, 1, 1) for day in range(1, 10): # print out the current day we are sending data for print date data = [] # 1440 minutes in one day for min in range(1, 1441): data.append(DataPoint(date, random.random() * 50.0)) date = date + datetime.timedelta(minutes=1) client.write_key(SERIES_KEY, data)
from tempodb import Client, DataPoint import struct import math import datetime import time import random import sys # credentials for tempodb API API_KEY = 'put API key here' API_SECRET = 'put API secret here' SERIES_KEY1 = 'luftdruck' SERIES_KEY2 = 'temperatur' HEIGHT=900 # we are 900m above sea level tempodbclient = Client(API_KEY, API_SECRET) dir(tempodbclient) def _TI_UUID(val): return UUID("%08X-0451-4000-b000-000000000000" % (0xF0000000+val)) class SensorBase: # Derived classes should set: svcUUID, ctrlUUID, dataUUID sensorOn = chr(0x01) sensorOff = chr(0x00) def __init__(self, periph): self.periph = periph self.service = self.periph.getServiceByUUID(self.svcUUID) self.ctrl = None
volRegEx = re.compile("numid=.*[\r\n]*.*min=([^,]*),max=([^,]*),step.*[\r\n]*.*values=([0-9]*)[\r\n]*",re.MULTILINE) volData = volRegEx.search(amixervals) if volData: vollimitdown = volData.group(1) vollimitup = volData.group(2) volvalue = int(volData.group(3)) else: print "AMIXER -c 0 cget name='",audioIface,"' didnt return the right results" sys.exit() volstep = (int(vollimitup) - int(vollimitdown)) / 10 print "[INIT]: ",AMIXER," limits from ",vollimitdown," to ",vollimitup,". Current volume is ",volvalue,". Volume Step is ",volstep i=0 tempArray = [] lightArray = [] softArray = [] client = Client(API_KEY, API_SECRET) while 1: sensors = ser.readline() #Temp: 26.66. Light: 125. softPot: 99 sensorsRegEx = re.compile("Temp: ([0-9.]*). Light: (\d{0,3}). softPot: (\d{0,3})") sensorsLine = sensorsRegEx.search(sensors) if i == 1000: sys.stderr.write("Sending data to tempodb...\n") client.write_key("light", lightArray) client.write_key("soft", softArray) client.write_key("temp", tempArray) tempArray = [] lightArray = [] softArray = [] i = 0 i+=1
""" http://tempo-db.com/api/write-series/#bulk-write-multiple-series """ from __future__ import print_function import datetime from tempodb import Client # Modify these with your credentials found at: http://tempo-db.com/manage/ API_KEY = 'your-api-key' API_SECRET = 'your-api-secret' SERIES_KEY = 'your-custom-key' client = Client(API_KEY, API_SECRET) ts = datetime.datetime.now() data = [ { 'key': 'custom-series-key1', 'v': 1.11 }, { 'key': 'custom-series-key2', 'v': 2.22 }, { 'key': 'custom-series-key3', 'v': 3.33 }, { 'key': 'custom-series-key4', 'v': 4.44 }, ] print(client.write_bulk(ts, data))
""" http://tempo-db.com/api/write-series/#write-series-by-key """ import datetime import random from tempodb import Client, DataPoint # Modify these with your credentials found at: http://tempo-db.com/manage/ API_KEY = '680d1adbbb0c42a398b5846c8e1517dd' API_SECRET = 'f2db65d178634a36b4c25467f8bc2099' SERIES_KEY = 'your-custom-key' client = Client(API_KEY, API_SECRET) date = datetime.datetime(2012, 1, 1) for day in range(1, 10): # print out the current day we are sending data for print date data = [] # 1440 minutes in one day for min in range (1, 1441): data.append(DataPoint(date, random.random() * 50.0)) date = date + datetime.timedelta(minutes=1) client.write_key(SERIES_KEY, data)
""" http://tempo-db.com/api/write-series/#write-series-by-key """ import datetime import random from tempodb import Client, DataPoint client = Client('your-api-key', 'your-api-secret') date = datetime.datetime(2012, 1, 1) for day in range(1, 10): # print out the current day we are sending data for print date data = [] # 1440 minutes in one day for min in range (1, 1441): data.append(DataPoint(date, random.random() * 50.0)) date = date + datetime.timedelta(minutes=1) client.write_key('your-custom-key', data)
import pygal import datetime import json import math from tempodb import Client from pygal.style import BlueStyle API_KEY = 'API_KEY' API_SECRET = 'API_SECRET' MILES_SERIES_KEY = 'divvy.trip.miles' TEMPERATURE_SERIES_KEY = 'divvy.trip.temperature' client = Client(API_KEY, API_SECRET) start = datetime.date(2013, 6, 27) end = start + datetime.timedelta(days=187) miles_data = client.read_key(MILES_SERIES_KEY, start, end, interval="1day", function="sum") miles_data_list = [] miles_data_count=0 for datapoint in miles_data.data: miles_data_list.append(datapoint.value) miles_data_count = miles_data_count + 1 # now do the same thing for the high temperature temperature_data = client.read_key(TEMPERATURE_SERIES_KEY, start, end) temperature_data_list = [] temperature_data_count=0
from tempodb import Client, DataPoint client = Client('40349331c03d4d4e9c544f812af291a9', 'f6e1594584a74f28ae00a872cd179462') for id in range(1,33): station='station_'+str(id).zfill(2) series = client.create_series(station)
import pygal import datetime import json import itertools from tempodb import Client from pygal.style import BlueStyle API_KEY = 'API_KEY' API_SECRET = 'API_SECRET' MILES_SERIES_KEY = 'divvy.trip.miles' PRECIP_SERIES_KEY = 'divvy.trip.precip' client = Client(API_KEY, API_SECRET) start = datetime.date(2013, 6, 27) end = start + datetime.timedelta(days=187) miles_data = client.read_key(MILES_SERIES_KEY, start, end, interval="1day", function="sum") miles_data_list = [] miles_data_count=0 for datapoint in miles_data.data: miles_data_list.append(datapoint.value) miles_data_count = miles_data_count + 1 # now do the same thing for precip precip_data = client.read_key(PRECIP_SERIES_KEY, start, end) precip_data_list = [] precip_data_count=0
class TempoDBArchive(object): def __init__(self, api_key, api_secret, interval=INTERVAL, keep_days=KEEP_DAYS): self.keep_days = datetime.timedelta(days=keep_days) self.interval = datetime.timedelta(hours=interval) self.client = Client(api_key, api_secret) def get_series_keys(self): try: return self._series_keys except AttributeError: self._series_keys = [p.key for p in self.client.get_series()] return self._series_keys def get_datapoints(self, series_key, delete=False): ts = datetime.datetime.utcnow() end = datetime.datetime(ts.year, ts.month, ts.day) - self.keep_days while True: start = end - self.interval data = self.client.read_key(series_key, start, end, tz='UTC') yield data.data if not data.data: break if delete: self.client.delete_key(series_key, start, end) end = start def write_sqlite(self, series_key, data, filename=DEFAULT_DATABASE_NAME): conn = sqlite3.connect(filename) cur = conn.cursor() # I know this might possibly run untrusted code but I'm not aware of # a built-in method for escaping identifiers and this is just an # archive tool. query = '''CREATE TABLE IF NOT EXISTS "{0}" ( timestamp text UNIQUE NOT NULL, value real NOT NULL)'''.format(series_key) cur.execute(query) query = 'INSERT INTO "{0}" values (?, ?)'.format(series_key) with conn: [cur.execute(query, (str(reading.ts), reading.value)) for reading in data] conn.close() def archive(self, series=None, delete=False): if series in (None, []): series_keys = self.get_series_keys() elif isinstance(series, str): series_keys = (series,) else: series_keys = series for key in series_keys: if key not in self.get_series_keys(): print('Series {0} does not exist'.format(key)) continue self.archive_series(key, delete) def archive_series(self, series_key, delete=False): start = datetime.datetime.utcnow() - self.keep_days start_date = datetime.datetime(start.year, start.month, start.day) for day, data in enumerate(self.get_datapoints(series_key, delete), 1): delta = self.interval * day archive_date = (start_date - delta).strftime("%Y-%m-%d") print('Archiving {0} for day {1}'.format(series_key, archive_date)) try: self.write_sqlite(series_key, data) except sqlite3.IntegrityError: print('Skipping', archive_date)
""" http://tempo-db.com/api/write-series/#bulk-write-multiple-series """ import datetime from tempodb import Client client = Client("your-api-key", "your-api-secret") bulk = { "t": datetime.datetime.now().isoformat(), "data": [ {"key": "custom-series-key1", "v": 1.11}, {"key": "custom-series-key2", "v": 2.22}, {"key": "custom-series-key3", "v": 3.33}, {"key": "custom-series-key4", "v": 4.44}, ], } print client.write_bulk(bulk)
import serial import math import datetime import random from tempodb import Client, DataPoint POTENTIAL_DIVIDER_RESISTOR = 10000 THERMISTOR_B_VALUE = 3977 THERMISTOR_REF_TEMP = 298.15 THERMISTOR_REF_RESISTANCE = 10000 client = Client('cc0c654d01774b128c1e0495de51784b', 'a280c43f6b27400998a4aba0b1eb4545') def calculate_temp(value): voltage = float(value) / 1024 * 5 resistance = POTENTIAL_DIVIDER_RESISTOR / (5 / voltage - 1) temp = 1 / (1/THERMISTOR_REF_TEMP + math.log(resistance / THERMISTOR_REF_RESISTANCE) / THERMISTOR_B_VALUE) print "Temperature is: %f K, (%f degC)" % (temp, temp-273.15) return temp-273.15 ser = serial.Serial('/dev/tty.usbserial-A800etDk', 9600) temperature_array = [] while 1: r = ser.readline() split = r.split(",") if(len(split) == 3): # Deal with the temperature pin first value = split[0].strip() temp = calculate_temp(value) temperature_array.append(temp) if(len(temperature_array) >= 20):
import datetime, time, ConfigParser from tempodb import Client, DataPoint # Modify these with your credentials found at: http://tempo-db.com/manage/ config = ConfigParser.ConfigParser() config.read('/home/pi/conf/config.cfg') KEY = config.get('KEYS', 'tempo.db.key') SECRET = config.get('KEYS', 'tempo.db.secret') client = Client(KEY, SECRET) def write(series, time, data): client.write_key(series, [DataPoint(time, data)])
""" http://tempo-db.com/api/read-series/#read-series-by-key """ import datetime from tempodb import Client # Modify these with your settings found at: http://tempo-db.com/manage/ API_KEY = 'baff599bbda949d48a223633b75569e0' API_SECRET = '79b79d2883874542a217afc9045b05e0' SERIES_KEY = 'test1' client = Client(API_KEY, API_SECRET) start = datetime.date(2012, 1, 1) end = start + datetime.timedelta(days=1) data = client.read_key(SERIES_KEY, start, end) for datapoint in data.data: print datapoint
""" http://tempo-db.com/api/write-series/#bulk-write-multiple-series """ from __future__ import print_function import datetime from tempodb import Client # Modify these with your credentials found at: http://tempo-db.com/manage/ API_KEY = 'your-api-key' API_SECRET = 'your-api-secret' SERIES_KEY = 'your-custom-key' client = Client(API_KEY, API_SECRET) ts = datetime.datetime.now() data = [ { 'key': 'custom-series-key1', 'v': 1.11 }, { 'key': 'custom-series-key2', 'v': 2.22 }, { 'key': 'custom-series-key3', 'v': 3.33 }, { 'key': 'custom-series-key4',
def init_tempo(api_key, api_secret): client = Client(api_key, api_secret) client.create_series('temp1') series1 = client.get_series(keys='temp1') if (len(series1) == 1): series1[0].tags = ["temp"] series1[0].attributes = { "source":"Thermostat", "description":"Nest", "location":"1st_Floor" } client.update_series(series1[0]) client.create_series('temp2') series2 = client.get_series(keys='temp2') if (len(series2) == 1): series2[0].tags = ["temp"] series2[0].attributes = { "source":"Weather Station", "description":"Weather Underground", "city":"Northwood", "state":"CA", "location":"Outdoor" } client.update_series(series2[0]) client.create_series('temp3') series3 = client.get_series(keys='temp3') if (len(series3) == 1): series3[0].tags = ["temp"] series3[0].attributes = { "source":"Temp Sensor", "description":"Raspberry Pi", "location":"2nd_Floor" } client.update_series(series3[0]) client.create_series('temp4') series4 = client.get_series(keys='temp4') if (len(series4) == 1): series4[0].tags = ["temp"] series4[0].attributes = { "source":"Temp Sensor", "description":"Arduino", "location":"Attic" } client.update_series(series4[0]) return client
def test_defaults(self): client = Client('key', 'secret') self.assertEqual(client.host, 'api.tempo-db.com') self.assertEqual(client.port, 443) self.assertEqual(client.secure, True)
class StatsdServer(object): def __init__(self, conf): TRUE_VALUES = set(('true', '1', 'yes', 'on', 't', 'y')) self.logger = logging.getLogger('statsdpy') self.logger.setLevel(logging.INFO) self.syslog = SysLogHandler() self.formatter = logging.Formatter('%(name)s: %(message)s') self.syslog.setFormatter(self.formatter) self.logger.addHandler(self.syslog) self.conf = conf self.graphite_host = conf.get('graphite_host', '127.0.0.1') self.graphite_port = int(conf.get('graphite_port', '2003')) self.listen_addr = conf.get('listen_addr', '127.0.0.1') self.listen_port = int(conf.get('listen_port', 8125)) self.debug = conf.get('debug', 'yes') in TRUE_VALUES self.combined_events = conf.get('combined_events', 'no') in TRUE_VALUES self.flush_interval = int(conf.get('flush_interval', 10)) self.pct_threshold = int(conf.get('percent_threshold', 90)) self.graphite_addr = (self.graphite_host, self.graphite_port) self.keycheck = re.compile(r'\s+|/|[^a-zA-Z_\-0-9\.]') self.ratecheck = re.compile('^@([\d\.]+)') self.counters = {} self.timers = {} self.stats_seen = 0 self.tempodb_enabled = conf.get('tempodb_enabled', 'false') in TRUE_VALUES self.tempodb_key = conf.get('tempodb_key', '') self.tempodb_secret = conf.get('tempodb_secret', '') self.tempodb_host = conf.get('tempodb_host', 'localhost') self.tempodb_port = int(conf.get('tempodb_port', 443)) self.tempodb_secure = conf.get('tempodb_secure', "true") in TRUE_VALUES self.tempodb_client = TempoDBClient(self.tempodb_key, self.tempodb_secret, \ self.tempodb_host, self.tempodb_port, \ self.tempodb_secure) def report_stats(self, payload): """ Send data """ if self.debug: print "reporting stats -> {\n%s}" % "".join(payload) self.report_stats_graphite(payload) if self.tempodb_enabled: self.report_stats_tempodb(payload) def report_stats_graphite(self, payload): """ Send data to graphite host :param stats: Data to send to graphite (list of graphite strings) """ try: with eventlet.Timeout(5, True) as timeout: graphite = socket.socket() graphite.connect(self.graphite_addr) graphite.sendall("".join(payload)) graphite.close() except Exception as err: self.logger.critical("error connecting to graphite: %s" % err) if self.debug: print "error connecting to graphite: %s" % err def report_stats_tempodb(self, payload): data = {} for stat in payload: components = stat[:-1].split(" ") if len(components) == 3: key = components[0] value = float(components[1]) ts = datetime.datetime.utcfromtimestamp(int(components[2])) data.setdefault(ts, list()).append({ 'key': key, 'v': value, }) try: with eventlet.Timeout(5, True): for key, value in data.items(): self.tempodb_client.write_bulk(key, value) except Exception as err: self.logger.critical("error connecting to tempodb: %s" % err) if self.debug: print "error connecting to tempodb: %s" % err def stats_flush(self): """ Periodically flush stats to graphite """ payload = [] while True: tstamp = int(time.time()) eventlet.sleep(self.flush_interval) if self.debug: print "seen %d stats so far." % self.stats_seen print "current counters: %s" % self.counters for item in self.counters: stats = 'stats.%s %s %s\n' % (item, self.counters[item] / self.flush_interval, tstamp) stats_counts = 'stats_counts.%s %s %s\n' % (item, self.counters[item], tstamp) payload.append(stats) payload.append(stats_counts) self.counters[item] = 0 for key in self.timers: if len(self.timers[key]) > 0: self.timers[key].sort() count = len(self.timers[key]) low = min(self.timers[key]) high = max(self.timers[key]) total = sum(self.timers[key]) mean = low max_threshold = high tstamp = int(time.time()) if count > 1: threshold_index = \ int((self.pct_threshold / 100.0) * count) max_threshold = self.timers[key][threshold_index - 1] mean = total / count payload.append("stats.timers.%s.mean %d %d\n" % \ (key, mean, tstamp)) payload.append("stats.timers.%s.upper %d %d\n" % \ (key, high, tstamp)) payload.append("stats.timers.%s.upper_%d %d %d\n" % \ (key, self.pct_threshold, max_threshold, tstamp)) payload.append("stats.timers.%s.lower %d %d\n" % \ (key, low, tstamp)) payload.append("stats.timers.%s.count %d %d\n" % \ (key, count, tstamp)) payload.append("stats.timers.%s.total %d %d\n" % \ (key, total, tstamp)) self.timers[key] = [] if payload: self.report_stats(payload) payload = [] def process_timer(self, key, fields): """ Process a received timer event :param key: Key of timer :param fields: Received fields """ try: if key not in self.timers: self.timers[key] = [] self.timers[key].append(float(fields[0] or 0)) if self.stats_seen >= maxint: self.logger.info("hit maxint, reset seen counter") self.stats_seen = 0 self.stats_seen += 1 except Exception as err: self.logger.info("error decoding timer event: %s" % err) if self.debug: print "error decoding timer event: %s" % err def process_counter(self, key, fields): """ Process a received counter event :param key: Key of counter :param fields: Received fields """ sample_rate = 1.0 try: if len(fields) is 3: if self.ratecheck.match(fields[2]): sample_rate = float(fields[2].lstrip("@")) else: raise Exception("bad sample rate.") counter_value = float(fields[0] or 1) * (1 / float(sample_rate)) if key not in self.counters: self.counters[key] = 0 self.counters[key] += counter_value if self.stats_seen >= maxint: self.logger.info("hit maxint, reset seen counter") self.stats_seen = 0 self.stats_seen += 1 except Exception as err: self.logger.info("error decoding counter event: %s" % err) if self.debug: print "error decoding counter event: %s" % err def decode_recvd(self, data): """ Decode and process the data from a received event. :param data: Data to decode and process. """ bits = data.split(':') if len(bits) == 2: key = self.keycheck.sub('_', bits[0]) print "got key: %s" % key fields = bits[1].split("|") field_count = len(fields) if field_count >= 2: if fields[1] == "ms": self.process_timer(key, fields) elif fields[1] == "c": self.process_counter(key, fields) else: if self.debug: print "error: unsupported stats type" print "key -> %s\nfields ->%s" % (key, fields) else: if self.debug: print "error: not enough fields received" else: if self.debug: print "error: invalid request" def run(self): eventlet.spawn_n(self.stats_flush) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) addr = (self.listen_addr, self.listen_port) sock.bind(addr) buf = 8192 self.logger.info("Listening on %s:%d" % addr) if self.debug: print "Listening on %s:%d" % addr if self.combined_events: if self.debug: print "combined_events mode enabled" while 1: data, addr = sock.recvfrom(buf) if not data: break else: for metric in data.split("#"): self.decode_recvd(metric) else: while 1: data, addr = sock.recvfrom(buf) if not data: break else: self.decode_recvd(data)
""" http://tempo-db.com/api/write-series/#bulk-write-multiple-series """ import datetime from tempodb import Client client = Client("your-api-key", "your-api-secret") ts = datetime.datetime.now() data = [ {"key": "custom-series-key1", "v": 1.11}, {"key": "custom-series-key2", "v": 2.22}, {"key": "custom-series-key3", "v": 3.33}, {"key": "custom-series-key4", "v": 4.44}, ] print client.write_bulk(ts, data)
""" http://tempo-db.com/api/read-series/#read-series-by-key """ import datetime from tempodb import Client client = Client('your-api-key', 'your-api-secret') start = datetime.date(2012, 1, 1) end = start + datetime.timedelta(days=1) data = client.read_key('your-custom-key', start, end) for datapoint in data: print datapoint