def test_protobuf_encoding(self):
enc = ProtobufEncoder()
bytes = enc.encode(SAMPLE_MSG)
eq_(ord(bytes[0]), RECORD_SEPARATOR)
header_len = ord(bytes[1])
header = bytes[2:2+header_len]
# Now double check the header
h = Header()
h.ParseFromString(header)
eq_(h.message_encoding,
Header.MessageEncoding.Value('PROTOCOL_BUFFER'))
eq_(ord(bytes[header_len+2]), UNIT_SEPARATOR)
pb_data = bytes[header_len+3:]
eq_(len(pb_data), h.message_length)
msg = Message()
msg.ParseFromString(pb_data)
eq_(msg.uuid, SAMPLE_MSG.uuid)
eq_(msg.timestamp, SAMPLE_MSG.timestamp)
eq_(msg.payload, SAMPLE_MSG.payload)
# Check the 3 fields
eq_(len(msg.fields), 4)
eq_(first_value(msg, 'foo'), 'bar')
eq_(first_value(msg, 'blah'), 42)
eq_(first_value(msg, 'cef_meta.syslog_name'), 'some-syslog-thing')
eq_(first_value(msg, 'cef_meta.syslog_level'), 5)
def test_timer_contextmanager(self):
name = self.timer_name
with self.client.timer(name) as timer:
time.sleep(0.01)
ok_(timer.result >= 10)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, str(timer.result))
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), self.timer_name)
eq_(first_value(full_msg, 'rate'), 1)
# Now disable it
self.client._disabled_timers.add(name)
with self.client.timer(name) as timer:
time.sleep(0.01)
ok_(timer.result is None)
# Now re-enable it
self.client._disabled_timers.remove(name)
self.client.sender.msgs.clear()
with self.client.timer(name) as timer:
time.sleep(0.01)
ok_(timer.result >= 10)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, str(timer.result))
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), name)
eq_(first_value(full_msg, 'rate'), 1.0)
def test_disable_all_timers(self):
name = self.timer_name
@self.client.timer(name)
def foo():
time.sleep(0.01)
foo()
eq_(len(self.stream.msgs), 1)
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10)
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), 'test')
eq_(first_value(full_msg, 'rate'), 1)
# Now disable everything
self.client._disabled_timers.add('*')
self.stream.msgs.clear()
@self.client.timer(name)
def foo2():
time.sleep(0.01)
foo2()
eq_(len(self.stream.msgs), 0)
def test_decorating_two_methods(self):
class Stub(object):
def __init__(self, value):
self.value = value
@timeit
def get_value1(self):
return self.value
@timeit
def get_value2(self):
return self.value
value = 7
stub = Stub(value)
eq_(stub.get_value1(), value)
eq_(stub.get_value2(), value)
eq_(stub.get_value1(), value)
eq_(stub.get_value2(), value)
msgs = [self._extract_msg(m) for m in self.client.sender.stream.msgs]
eq_(len(msgs), 4)
eq_(first_value(msgs[0], 'name'),
'heka.tests.test_decorators.get_value1')
eq_(first_value(msgs[1], 'name'),
'heka.tests.test_decorators.get_value2')
def test_decorating_two_methods(self):
class Stub(object):
def __init__(self, value):
self.value = value
@timeit
def get_value1(self):
return self.value
@timeit
def get_value2(self):
return self.value
value = 7
stub = Stub(value)
eq_(stub.get_value1(), value)
eq_(stub.get_value2(), value)
eq_(stub.get_value1(), value)
eq_(stub.get_value2(), value)
msgs = [self._extract_msg(m) for m in self.stream.msgs]
eq_(len(msgs), 4)
eq_(first_value(msgs[0], 'name'),
'heka.tests.test_decorators.get_value1')
eq_(first_value(msgs[1], 'name'),
'heka.tests.test_decorators.get_value2')
def test_disable_all_timers(self):
name = self.timer_name
@self.client.timer(name)
def foo():
time.sleep(0.01)
foo()
eq_(len(self.client.sender.msgs), 1)
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10)
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), 'test')
eq_(first_value(full_msg, 'rate'), 1)
# Now disable everything
self.client._disabled_timers.add('*')
self.client.sender.msgs.clear()
@self.client.timer(name)
def foo2():
time.sleep(0.01)
foo2()
eq_(len(self.mock_sender.msgs), 0)
def test_protobuf_encoding(self):
enc = ProtobufEncoder()
bytes = enc.encode(SAMPLE_MSG)
eq_(ord(bytes[0]), RECORD_SEPARATOR)
header_len = ord(bytes[1])
header = bytes[2:2+header_len]
# Now double check the header
h = Header()
h.ParseFromString(header)
eq_(ord(bytes[header_len+2]), UNIT_SEPARATOR)
pb_data = bytes[header_len+3:]
eq_(len(pb_data), h.message_length)
msg = Message()
msg.ParseFromString(pb_data)
eq_(msg.uuid, SAMPLE_MSG.uuid)
eq_(msg.timestamp, SAMPLE_MSG.timestamp)
eq_(msg.payload, SAMPLE_MSG.payload)
# Check the 3 fields
eq_(len(msg.fields), 4)
eq_(first_value(msg, 'foo'), 'bar')
eq_(first_value(msg, 'blah'), 42)
eq_(first_value(msg, 'cef_meta.syslog_name'), 'some-syslog-thing')
eq_(first_value(msg, 'cef_meta.syslog_level'), 5)
def test_timer_contextmanager(self):
name = self.timer_name
with self.client.timer(name) as timer:
time.sleep(0.01)
ok_(timer.result >= 10)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, str(timer.result))
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), self.timer_name)
eq_(first_value(full_msg, 'rate'), 1)
# Now disable it
self.client._disabled_timers.add(name)
with self.client.timer(name) as timer:
time.sleep(0.01)
ok_(timer.result is None)
# Now re-enable it
self.client._disabled_timers.remove(name)
self.stream.msgs.clear()
with self.client.timer(name) as timer:
time.sleep(0.01)
ok_(timer.result >= 10)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, str(timer.result))
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), name)
eq_(first_value(full_msg, 'rate'), 1.0)
def test_timer_contextmanager(self):
name = self.timer_name
with self.client.timer(name) as timer:
time.sleep(0.01)
ok_(timer.result >= 10)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, str(timer.result))
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), name)
eq_(first_value(full_msg, 'rate'), 1)
def test_timer_contextmanager(self):
name = self.timer_name
with self.client.timer(name) as timer:
time.sleep(0.01)
ok_(timer.result >= 10)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, str(timer.result))
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), name)
eq_(first_value(full_msg, 'rate'), 1)
def test_timer_decorator(self):
@self.client.timer(self.timer_name)
def timed():
time.sleep(0.01)
ok_(not len(self.mock_stream.msgs))
timed()
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10)
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), self.timer_name)
eq_(first_value(full_msg, 'rate'), 1)
eq_(first_value(full_msg, 'rate'), 1)
def test_timer_decorator(self):
@self.client.timer(self.timer_name)
def timed():
time.sleep(0.01)
ok_(not self.mock_sender.send_message.called)
timed()
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10)
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), self.timer_name)
eq_(first_value(full_msg, 'rate'), 1)
eq_(first_value(full_msg, 'rate'), 1)
def test_timer_decorator(self):
@self.client.timer(self.timer_name)
def timed():
time.sleep(0.01)
ok_(not len(self.mock_stream.msgs))
timed()
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10)
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), self.timer_name)
eq_(first_value(full_msg, 'rate'), 1)
eq_(first_value(full_msg, 'rate'), 1)
def test_decorating_methods_in_a_class(self):
class Stub(object):
def __init__(self, value):
self.value = value
@incr_count
@timeit
def get_value(self):
return self.value
stub = Stub(7)
eq_(stub.get_value(), 7)
msgs = [self._extract_msg(m) for m in self.stream.msgs]
eq_(len(msgs), 2)
for msg in msgs:
expected = 'heka.tests.test_decorators.get_value'
eq_(first_value(msg, 'name'), expected)
# First msg should be counter, then timer as decorators are
# applied inside to out, but execution is outside -> in
eq_(msgs[0].type, 'timer')
eq_(msgs[1].type, 'counter')
self.stream.msgs.clear()
def test_gauge(self):
name = 'gauge'
self.client.gauge(name, 10)
full_msg = self._extract_full_msg()
eq_(full_msg.type, 'gauge')
eq_(full_msg.logger, self.logger)
eq_(first_value(full_msg, 'name'), name)
# You have to have a rate set here
eq_(first_value(full_msg, 'rate'), 1)
eq_(full_msg.payload, '10')
self.client.incr(name, 20)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, '20')
def test_incr(self):
name = 'incr'
self.client.incr(name)
full_msg = self._extract_full_msg()
eq_(full_msg.type, 'counter')
eq_(full_msg.logger, self.logger)
eq_(first_value(full_msg, 'name'), name)
# You have to have a rate set here
eq_(first_value(full_msg, 'rate'), 1)
eq_(full_msg.payload, '1')
self.client.incr(name, 10)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, '10')
def test_gauge(self):
name = 'gauge'
self.client.gauge(name, 10)
full_msg = self._extract_full_msg()
eq_(full_msg.type, 'gauge')
eq_(full_msg.logger, self.logger)
eq_(first_value(full_msg, 'name'), name)
# You have to have a rate set here
eq_(first_value(full_msg, 'rate'), 1)
eq_(full_msg.payload, '10')
self.client.incr(name, 20)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, '20')
def test_incr(self):
name = 'incr'
self.client.incr(name)
full_msg = self._extract_full_msg()
eq_(full_msg.type, 'counter')
eq_(full_msg.logger, self.logger)
eq_(first_value(full_msg, 'name'), name)
# You have to have a rate set here
eq_(first_value(full_msg, 'rate'), 1)
eq_(full_msg.payload, '1')
self.client.incr(name, 10)
full_msg = self._extract_full_msg()
eq_(full_msg.payload, '10')
def test_decorating_methods_in_a_class(self):
class Stub(object):
def __init__(self, value):
self.value = value
@incr_count
@timeit
def get_value(self):
return self.value
stub = Stub(7)
eq_(stub.get_value(), 7)
msgs = [self._extract_msg(m) for m in self.client.sender.stream.msgs]
eq_(len(msgs), 2)
for msg in msgs:
expected = 'heka.tests.test_decorators.get_value'
eq_(first_value(msg, 'name'), expected)
# First msg should be counter, then timer as decorators are
# applied inside to out, but execution is outside -> in
eq_(msgs[0].type, 'timer')
eq_(msgs[1].type, 'counter')
self.client.sender.stream.msgs.clear()
def check_bytes(self, bytes, value):
new_msg = Message()
new_msg.ParseFromString(bytes)
assert new_msg.uuid == '0123456789012345'
assert new_msg.type == 'demo'
assert new_msg.timestamp == 1000000
assert first_value(new_msg, 'myfield') == value
def check_bytes(self, bytes, value):
new_msg = Message()
new_msg.ParseFromString(bytes)
assert new_msg.uuid == '0123456789012345'
assert new_msg.type == 'demo'
assert new_msg.timestamp == 1000000
assert first_value(new_msg, 'myfield') == value
def test_timer_decorator(self):
name = self.timer_name
@self.client.timer(name)
def foo():
time.sleep(0.01)
foo()
eq_(len(self.client.sender.msgs), 1)
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10, "Got: %d" % int(full_msg.payload))
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), 'test')
eq_(first_value(full_msg, 'rate'), 1)
# Now disable it
self.client._disabled_timers.add(name)
self.client.sender.msgs.clear()
@self.client.timer(name)
def foo2():
time.sleep(0.01)
foo2()
eq_(len(self.mock_sender.msgs), 0)
# Now re-enable it
self.client._disabled_timers.remove(name)
self.client.sender.msgs.clear()
@self.client.timer(name)
def foo3():
time.sleep(0.01)
foo3()
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10)
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), 'test')
eq_(first_value(full_msg, 'rate'), 1)
def test_timer_decorator(self):
name = self.timer_name
@self.client.timer(name)
def foo():
time.sleep(0.01)
foo()
eq_(len(self.stream.msgs), 1)
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10,
"Got: %d" % int(full_msg.payload))
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), 'test')
eq_(first_value(full_msg, 'rate'), 1)
# Now disable it
self.client._disabled_timers.add(name)
self.stream.msgs.clear()
@self.client.timer(name)
def foo2():
time.sleep(0.01)
foo2()
eq_(len(self.stream.msgs), 0)
# Now re-enable it
self.client._disabled_timers.remove(name)
self.stream.msgs.clear()
@self.client.timer(name)
def foo3():
time.sleep(0.01)
foo3()
full_msg = self._extract_full_msg()
ok_(int(full_msg.payload) >= 10)
eq_(full_msg.type, 'timer')
eq_(first_value(full_msg, 'name'), 'test')
eq_(first_value(full_msg, 'rate'), 1)
def test_passed_decorator_args(self):
name = 'different.timer.name'
@timeit(name)
def timed_fn(x, y):
return x + y
eq_(timed_fn(3, 5), 8)
msgs = [self._extract_msg(m) for m in self.client.sender.stream.msgs]
msg = msgs[-1]
eq_(msg.type, 'timer')
eq_(first_value(msg, 'name'), name)
def test_passed_decorator_args(self):
name = 'different.timer.name'
@timeit(name)
def timed_fn(x, y):
return x + y
eq_(timed_fn(3, 5), 8)
msgs = [self._extract_msg(m) for m in self.stream.msgs]
msg = msgs[-1]
eq_(msg.type, 'timer')
eq_(first_value(msg, 'name'), name)
def test_decorator_ordering(self):
@incr_count
@timeit
def ordering_1(x, y):
return x + y
eq_(ordering_1(5, 6), 11)
msgs = [self._extract_msg(m) for m in self.client.sender.stream.msgs]
eq_(len(msgs), 2)
for msg in msgs:
expected = 'heka.tests.test_decorators.ordering_1'
eq_(first_value(msg, 'name'), expected)
# First msg should be counter, then timer as decorators are
# applied inside to out, but execution is outside -> in
eq_(msgs[0].type, 'timer')
eq_(msgs[1].type, 'counter')
self.client.sender.stream.msgs.clear()
@timeit
@incr_count
def ordering_2(x, y):
return x + y
ordering_2(5, 6)
msgs = [self._extract_msg(m) for m in self.client.sender.stream.msgs]
eq_(len(msgs), 2)
for msg in msgs:
expected = 'heka.tests.test_decorators.ordering_2'
eq_(first_value(msg, 'name'), expected)
# Ordering of log messages should occur in the in->out
# ordering of decoration
eq_(msgs[0].type, 'counter')
eq_(msgs[1].type, 'timer')
def test_decorator_ordering(self):
@incr_count
@timeit
def ordering_1(x, y):
return x + y
eq_(ordering_1(5, 6), 11)
msgs = [self._extract_msg(m) for m in self.stream.msgs]
eq_(len(msgs), 2)
for msg in msgs:
expected = 'heka.tests.test_decorators.ordering_1'
eq_(first_value(msg, 'name'), expected)
# First msg should be counter, then timer as decorators are
# applied inside to out, but execution is outside -> in
eq_(msgs[0].type, 'timer')
eq_(msgs[1].type, 'counter')
self.stream.msgs.clear()
@timeit
@incr_count
def ordering_2(x, y):
return x + y
ordering_2(5, 6)
msgs = [self._extract_msg(m) for m in self.stream.msgs]
eq_(len(msgs), 2)
for msg in msgs:
expected = 'heka.tests.test_decorators.ordering_2'
eq_(first_value(msg, 'name'), expected)
# Ordering of log messages should occur in the in->out
# ordering of decoration
eq_(msgs[0].type, 'counter')
eq_(msgs[1].type, 'timer')
def msg_to_payload(self, msg):
log_level = first_value(msg, 'loglevel')
if log_level is None:
# Try computing it from msg.severity
if msg.severity:
log_level = LOGLEVEL_MAP[msg.severity]
else:
log_level = logging.INFO
f = msg.fields.add()
f.name = 'loglevel'
f.representation = ""
f.value_type = Field.INTEGER
f.value_integer.append(log_level)
data = msg.payload
return pack('B10s', log_level, msg.type[:10] + (" "*(10-len(msg.type)))) + data
def test_specific_timer_disabled(self):
@timeit
def simple(x, y):
return x + y
@timeit
def simple2(x, y):
return x + y
omit = ('heka.tests.test_decorators.simple')
self.client._disabled_timers = set([omit])
simple(1, 2)
simple2(3, 4)
msgs = [self._extract_msg(m) for m in self.client.sender.stream.msgs]
eq_(len(msgs), 1)
eq_(first_value(msgs[0], 'name'), 'heka.tests.test_decorators.simple2')
def msg_to_payload(self, msg):
log_level = first_value(msg, 'loglevel')
if log_level is None:
# Try computing it from msg.severity
if msg.severity:
log_level = LOGLEVEL_MAP[msg.severity]
else:
log_level = logging.INFO
f = msg.fields.add()
f.name = 'loglevel'
f.representation = ""
f.value_type = Field.INTEGER
f.value_integer.append(log_level)
data = msg.payload
return pack('B10s', log_level, msg.type[:10] +
(" " * (10 - len(msg.type)))) + data
def test_specific_timer_disabled(self):
@timeit
def simple(x, y):
return x + y
@timeit
def simple2(x, y):
return x + y
omit = ('heka.tests.test_decorators.simple')
self.client._disabled_timers = set([omit])
simple(1, 2)
simple2(3, 4)
msgs = [self._extract_msg(m) for m in self.stream.msgs]
eq_(len(msgs), 1)
eq_(first_value(msgs[0], 'name'), 'heka.tests.test_decorators.simple2')
