class Common(object):
def __init__(self, ):
self.api = API()
self.usage_args = ""
# Set our application id from the environment variable
self.app_id = os.environ['TSI_APP_ID']
@staticmethod
def usage(args):
sys.stderr.write("usage: {0} {1}\n".format(os.path.basename(sys.argv[0]), args))
def send_measurements(self, measurements):
"""
Sends measurements using the Measurement API
:param measurements:
:return: None
"""
self.api.measurement_create_batch(measurements)
def run(self):
"""
Main loop
"""
while True:
print("Doing absolutely nothing")
time.sleep(self.interval)
class Common(object):
def __init__(self, ):
self.api = API()
self.usage_args = ""
# Set our application id from the environment variable
self.app_id = os.environ['TSI_APP_ID']
@staticmethod
def usage(args):
sys.stderr.write("usage: {0} {1}\n".format(
os.path.basename(sys.argv[0]), args))
def send_measurements(self, measurements):
"""
Sends measurements using the Measurement API
:param measurements:
:return: None
"""
self.api.measurement_create_batch(measurements)
def run(self):
"""
Main loop
"""
while True:
print("Doing absolutely nothing")
time.sleep(self.interval)
def create_batch():
delay = 30
api = API()
measurements = []
timestamp = int(datetime.now().strftime('%s'))
# skew timestamp by 5 seconds
timestamp = timestamp - delay
measurements.append(Measurement(metric='API_TEST_METRIC', value=randint(0, 99), source='red', timestamp=timestamp))
measurements.append(Measurement(metric='API_TEST_METRIC', value=randint(0, 99), source='green', timestamp=timestamp))
measurements.append(Measurement(metric='API_TEST_METRIC', value=randint(0, 99), source='blue', timestamp=timestamp))
# sleep(float(delay))
api.measurement_create_batch(measurements)
class ApacheLogfileParser(LogfileParser):
def __init__(self, path=None):
super(ApacheLogfileParser, self).__init__(path)
log_format = r'%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}\i"'
self.parser = apachelog.parser(log_format)
self.api = API()
logging.basicConfig(level=logging.INFO)
def send_measurements(self, measurements):
"""
Sends measurements to standard out to be read by plugin manager
:param measurements:
:return: None
"""
self.api.measurement_create_batch(measurements)
def parse_line(self):
"""
Parse each of the lines of the Apache HTTP server access log.
:return:
"""
parsed = parse_apache_line(self.parser, self.line)
measurements = []
user_agent = parsed['%{User-Agent}\i"'].replace('/', '')
bytes = int(parsed['%b'])
status_code = parsed['%>s']
properties = {"app_id": self.app_id}
# Split the line by spaces and get the request in the first value
request = parsed['%r'].split(' ')[0]
logging.info("user_agent: {0}, bytes: {1}, request: {2}, status_code: {3}".format(
user_agent, bytes, request, status_code))
measurements.append(Measurement(
metric='HTTP_REQUESTS',
value=1,
source=request,
properties=properties))
measurements.append(Measurement(
metric='HTTP_BYTES',
value=bytes,
source=user_agent,
properties=properties))
self.send_measurements(measurements)
class APIDataSink(DataSink):
def __init__(self, email=None, api_token=None, api_host=None):
super(APIDataSink, self).__init__()
self._api = API(email=email, api_token=api_token, api_host=api_host)
def send_event(self, event):
pass
def send_events(self, events):
pass
def send_measurement(self, measurement):
self._api.measurement_create(metric=measurement.metric,
value=measurement.value,
source=measurement.source,
timestamp=measurement.timestamp,
properties=measurement.properties)
def send_measurements(self, measurements):
self._api.measurement_create_batch(measurements)
class MeasurementTest(TestCase):
def setUp(self):
self.api = API()
def test_measurement_constructor(self):
metric = 'CPU'
value = 0.5
source = 'foobar'
timestamp = int(datetime.now().strftime('%s'))
properties = {"app_id": "red", "source_type": "blue", "origin": "green"}
measurement = Measurement(metric=metric, value=value, source=source,
timestamp=timestamp, properties=properties)
self.assertEqual(metric, measurement.metric)
self.assertEqual(value, measurement.value)
self.assertEqual(source, measurement.source)
self.assertEqual(timestamp, measurement.timestamp)
self.assertEqual(properties, measurement.properties)
def test_measurement_defaults(self):
measurement = Measurement()
self.assertIsNone(measurement.metric)
self.assertIsNone(measurement.value)
self.assertIsNone(measurement.source)
self.assertIsNone(measurement.timestamp)
self.assertIsNone(measurement.properties)
def test_measurement_create(self):
metric_id = 'CPU'
value = 0.75
source = 'API_TEST_SOURCE'
timestamp = int(datetime.now().strftime('%s'))
self.api.measurement_create(metric_id, value, source, timestamp)
def test_measurement_create_datetime(self):
metric_id = 'CPU'
value = 0.75
source = 'API_TEST_SOURCE'
timestamp = datetime.now()
self.api.measurement_create(metric_id, value, source, timestamp)
def test_measurement_create_with_properties(self):
metric_id = 'CPU'
value = 0.75
source = 'API_TEST_SOURCE'
timestamp = int(datetime.now().strftime('%s'))
properties = {"app_id": "red", "source_type": "blue", "origin": "green"}
self.api.measurement_create(metric=metric_id, value=value, source=source,
timestamp=timestamp, properties=properties)
def test_measurement_create_batch(self):
measurements = []
timestamp = int(datetime.now().strftime('%s'))
measurements.append(Measurement(metric='CPU', value=0.5, source='red', timestamp=timestamp))
measurements.append(Measurement(metric='CPU', value=0.6, source='green', timestamp=timestamp))
measurements.append(Measurement(metric='CPU', value=0.7, source='blue', timestamp=timestamp))
self.api.measurement_create_batch(measurements)
def test_measurement_create_batch_datetime(self):
measurements = []
timestamp = datetime.now()
measurements.append(Measurement(metric='CPU', value=0.5, source='red', timestamp=timestamp))
measurements.append(Measurement(metric='CPU', value=0.6, source='green', timestamp=timestamp))
measurements.append(Measurement(metric='CPU', value=0.7, source='blue', timestamp=timestamp))
self.api.measurement_create_batch(measurements)
def test_measurement_create_batch_with_properties(self):
measurements = []
properties = {"app_id": "red", "source_type": "blue", "origin": "green"}
timestamp = int(datetime.now().strftime('%s'))
measurements.append(Measurement(metric='CPU', value=0.5, source='red',
timestamp=timestamp, properties=properties))
measurements.append(Measurement(metric='CPU', value=0.6, source='green',
timestamp=timestamp, properties=properties))
measurements.append(Measurement(metric='CPU', value=0.7, source='blue',
timestamp=timestamp, properties=properties))
self.api.measurement_create_batch(measurements)
def test_measurement_get(self):
metric = 'CPU'
value = 0.0
source = 'API_TEST_SOURCE' + TestUtils.random_string(6)
properties = {"app_id": "red", "source_type": "blue", "origin": "green"}
start = int(datetime.now().strftime('%s'))
timestamp = start
for i in range(0, 10):
self.api.measurement_create(metric=metric, value=value, source=source,
timestamp=timestamp, properties=properties)
timestamp += 1
value += 0.1
measurements = self.api.measurement_get(source=source, start=start, aggregate='avg')
value = 0.0
timestamp = start
for measure in measurements:
self.assertEqual(metric, measure.metric)
self.assertEqual(value, measure.value)
self.assertEqual(source, measure.source)
self.assertEqual(timestamp, measure.timestamp/1000)
timestamp += 1
value += 0.1
def test_parse_timestamp_date_string_yymmddhhmm(self):
d = datetime.utcnow()
s = d.strftime('%Y-%m-%d %H:%M:%S')
ts = Measurement.parse_timestamp(s)
self.assertEqual(type(ts), int)
self.assertEqual(ts, int(d.strftime('%s')))
def test_parse_timestamp_date_string_yymmddhhmmss(self):
d = datetime.utcnow()
s = d.strftime('%Y-%m-%d %I:%M:%S%p')
ts = Measurement.parse_timestamp(s)
self.assertEqual(type(ts), int)
self.assertEqual(ts, int(d.strftime('%s')))
def test_parse_timestamp_date_string_yymmddHHMM(self):
d = datetime.utcnow()
s = d.strftime('%Y-%m-%d %I:%M:%S%p')
ts = Measurement.parse_timestamp(s)
self.assertEqual(type(ts), int)
self.assertEqual(ts, int(d.strftime('%s')))
def test_parse_timestamp_date_string_epoch_time(self):
s = '1466704787'
d = Measurement.parse_timestamp(s)
self.assertEqual(type(d), int)
self.assertEqual(d, 1466704787)
class Driver(object):
def __init__(self, email=None, api_token=None):
self._wm = None
self._api = API(email=email, api_token=api_token)
self._buttons = None
self._accelerometers = None
self._measurements = None
self._timestamp = None
def queue_measurement(self, metric, value, source):
self._measurements.append(Measurement(metric=metric, value=value, source=source, timestamp=self._timestamp))
def send_measurements(self):
logging.debug('send measurements')
self._api.measurement_create_batch(self._measurements)
def connect(self, retries=10):
"""
Attempt to connect to the Wiimote
:param retries: Number of times to attempting connection before raising an exception.
:return:
"""
print('Press 1+2 on your Wiimote now...')
i = 1
while self._wm is None:
try:
self._wm = cwiid.Wiimote()
except RuntimeError:
logging.error("Error opening wiimote connection, attempt: {0}".format(str(i)))
i += 1
if i > retries:
raise RuntimeError
self._wm.rpt_mode = cwiid.RPT_BTN | cwiid.RPT_ACC | cwiid.RPT_STATUS
print("connected!")
def button_status(self, button):
return 1 if self._buttons & button else 0
def collect_init(self):
# Initialze the array to hold the collected measurements
self._measurements = []
# Get the current time and use for all measurements
self._timestamp = int(datetime.now().strftime('%s'))
# Snapshot the current state of buttons and accelerometers
self._buttons = self._wm.state['buttons']
self._accelerometers = self._wm.state['acc']
self._battery = self._wm.state['battery']
def collect_battery_status(self):
self.queue_measurement('WIIMOTE_BATTERY', float(self._battery)/100.0, 'battery')
def collect_button_status(self):
button_left = self.button_status(cwiid.BTN_LEFT)
self.queue_measurement('WIIMOTE_BUTTON_LEFT', button_left, 'button-left')
self.queue_measurement('WIIMOTE_BUTTON', button_left, 'button-left')
button_right = self.button_status(cwiid.BTN_RIGHT)
self.queue_measurement('WIIMOTE_BUTTON_RIGHT', button_right, 'button-right')
self.queue_measurement('WIIMOTE_BUTTON', button_right, 'button-right')
button_up = self.button_status(cwiid.BTN_UP)
self.queue_measurement('WIIMOTE_BUTTON_UP', button_up, 'button-up')
self.queue_measurement('WIIMOTE_BUTTON', button_up, 'button-up')
button_down = self.button_status(cwiid.BTN_DOWN)
self.queue_measurement('WIIMOTE_BUTTON_DOWN', button_down, 'button-down')
self.queue_measurement('WIIMOTE_BUTTON', button_down, 'button-down')
button_1 = self.button_status(cwiid.BTN_1)
self.queue_measurement('WIIMOTE_BUTTON_1', button_1, 'button-1')
self.queue_measurement('WIIMOTE_BUTTON', button_1, 'button-1')
button_2 = self.button_status(cwiid.BTN_2)
self.queue_measurement('WIIMOTE_BUTTON_2', button_2, 'button-2')
self.queue_measurement('WIIMOTE_BUTTON', button_2, 'button-2')
button_a = self.button_status(cwiid.BTN_A)
self.queue_measurement('WIIMOTE_BUTTON_A', button_a, 'button-a')
self.queue_measurement('WIIMOTE_BUTTON', button_a, 'button-a')
button_b = self.button_status(cwiid.BTN_B)
self.queue_measurement('WIIMOTE_BUTTON_B', button_b, 'button-b')
self.queue_measurement('WIIMOTE_BUTTON', button_b, 'button-b')
button_home = self.button_status(cwiid.BTN_HOME)
self.queue_measurement('WIIMOTE_BUTTON_HOME', button_home, 'button-home')
self.queue_measurement('WIIMOTE_BUTTON', button_home, 'button-home')
button_minus = self.button_status(cwiid.BTN_MINUS)
self.queue_measurement('WIIMOTE_BUTTON_MINUS', button_minus, 'button-minus')
self.queue_measurement('WIIMOTE_BUTTON', button_minus, 'button-minus')
button_plus = self.button_status(cwiid.BTN_PLUS)
self.queue_measurement('WIIMOTE_BUTTON_PLUS', button_plus, 'button-plus')
self.queue_measurement('WIIMOTE_BUTTON', button_plus, 'button-plus')
def collect_accelerator_status(self):
self.queue_measurement('WIIMOTE_ACCELEROMETER_X', self._accelerometers[0], 'accelerometer-x')
self.queue_measurement('WIIMOTE_ACCELEROMETER_Y', self._accelerometers[1], 'accelerometer-y')
self.queue_measurement('WIIMOTE_ACCELEROMETER_Z', self._accelerometers[2], 'accelerometer-z')
self.queue_measurement('WIIMOTE_ACCELEROMETER', self._accelerometers[0], 'accelerometer-x');
self.queue_measurement('WIIMOTE_ACCELEROMETER', self._accelerometers[1], 'accelerometer-y');
self.queue_measurement('WIIMOTE_ACCELEROMETER', self._accelerometers[2], 'accelerometer-z');
def collection_loop(self):
logging.debug("start collection loop")
while True:
self.collect_init()
self.collect_battery_status()
self.collect_button_status()
self.collect_accelerator_status()
self.send_measurements()
def run(self):
self.connect()
self.collection_loop()
class MeasurementTest(TestCase):
def setUp(self):
self.api = API()
def test_measurement_constructor(self):
metric = 'CPU'
value = 0.5
source = 'foobar'
timestamp = int(datetime.now().strftime('%s'))
properties = {
"app_id": "red",
"source_type": "blue",
"origin": "green"
}
measurement = Measurement(metric=metric,
value=value,
source=source,
timestamp=timestamp,
properties=properties)
self.assertEqual(metric, measurement.metric)
self.assertEqual(value, measurement.value)
self.assertEqual(source, measurement.source)
self.assertEqual(timestamp, measurement.timestamp)
self.assertEqual(properties, measurement.properties)
def test_measurement_defaults(self):
measurement = Measurement()
self.assertIsNone(measurement.metric)
self.assertIsNone(measurement.value)
self.assertIsNone(measurement.source)
self.assertIsNone(measurement.timestamp)
self.assertIsNone(measurement.properties)
def test_measurement_create(self):
metric_id = 'CPU'
value = 0.75
source = 'API_TEST_SOURCE'
timestamp = int(datetime.now().strftime('%s'))
self.api.measurement_create(metric_id, value, source, timestamp)
def test_measurement_create_datetime(self):
metric_id = 'CPU'
value = 0.75
source = 'API_TEST_SOURCE'
timestamp = datetime.now()
self.api.measurement_create(metric_id, value, source, timestamp)
def test_measurement_create_with_properties(self):
metric_id = 'CPU'
value = 0.75
source = 'API_TEST_SOURCE'
timestamp = int(datetime.now().strftime('%s'))
properties = {
"app_id": "red",
"source_type": "blue",
"origin": "green"
}
self.api.measurement_create(metric=metric_id,
value=value,
source=source,
timestamp=timestamp,
properties=properties)
def test_measurement_create_batch(self):
measurements = []
timestamp = int(datetime.now().strftime('%s'))
measurements.append(
Measurement(metric='CPU',
value=0.5,
source='red',
timestamp=timestamp))
measurements.append(
Measurement(metric='CPU',
value=0.6,
source='green',
timestamp=timestamp))
measurements.append(
Measurement(metric='CPU',
value=0.7,
source='blue',
timestamp=timestamp))
self.api.measurement_create_batch(measurements)
def test_measurement_create_batch_datetime(self):
measurements = []
timestamp = datetime.now()
measurements.append(
Measurement(metric='CPU',
value=0.5,
source='red',
timestamp=timestamp))
measurements.append(
Measurement(metric='CPU',
value=0.6,
source='green',
timestamp=timestamp))
measurements.append(
Measurement(metric='CPU',
value=0.7,
source='blue',
timestamp=timestamp))
self.api.measurement_create_batch(measurements)
def test_measurement_create_batch_with_properties(self):
measurements = []
properties = {
"app_id": "red",
"source_type": "blue",
"origin": "green"
}
timestamp = int(datetime.now().strftime('%s'))
measurements.append(
Measurement(metric='CPU',
value=0.5,
source='red',
timestamp=timestamp,
properties=properties))
measurements.append(
Measurement(metric='CPU',
value=0.6,
source='green',
timestamp=timestamp,
properties=properties))
measurements.append(
Measurement(metric='CPU',
value=0.7,
source='blue',
timestamp=timestamp,
properties=properties))
self.api.measurement_create_batch(measurements)
def test_measurement_get(self):
metric = 'CPU'
value = 0.0
source = 'API_TEST_SOURCE' + TestUtils.random_string(6)
properties = {
"app_id": "red",
"source_type": "blue",
"origin": "green"
}
start = int(datetime.now().strftime('%s'))
timestamp = start
for i in range(0, 10):
self.api.measurement_create(metric=metric,
value=value,
source=source,
timestamp=timestamp,
properties=properties)
timestamp += 1
value += 0.1
measurements = self.api.measurement_get(source=source,
start=start,
aggregate='avg')
value = 0.0
timestamp = start
for measure in measurements:
self.assertEqual(metric, measure.metric)
self.assertEqual(value, measure.value)
self.assertEqual(source, measure.source)
self.assertEqual(timestamp, measure.timestamp / 1000)
timestamp += 1
value += 0.1
def test_parse_timestamp_date_string_yymmddhhmm(self):
d = datetime.utcnow()
s = d.strftime('%Y-%m-%d %H:%M:%S')
ts = Measurement.parse_timestamp(s)
self.assertEqual(type(ts), int)
self.assertEqual(ts, int(d.strftime('%s')))
def test_parse_timestamp_date_string_yymmddhhmmss(self):
d = datetime.utcnow()
s = d.strftime('%Y-%m-%d %I:%M:%S%p')
ts = Measurement.parse_timestamp(s)
self.assertEqual(type(ts), int)
self.assertEqual(ts, int(d.strftime('%s')))
def test_parse_timestamp_date_string_yymmddHHMM(self):
d = datetime.utcnow()
s = d.strftime('%Y-%m-%d %I:%M:%S%p')
ts = Measurement.parse_timestamp(s)
self.assertEqual(type(ts), int)
self.assertEqual(ts, int(d.strftime('%s')))
def test_parse_timestamp_date_string_epoch_time(self):
s = '1466704787'
d = Measurement.parse_timestamp(s)
self.assertEqual(type(d), int)
self.assertEqual(d, 1466704787)
