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
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)
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
"""
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 __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 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)
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')
"""
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
