def test_heka_full(self):
heka_args = dict(payload='this is another test',
logger='alternate',
severity=2,
fields={
'foo': 'bar',
'boo': 'far'
})
msgtype = 'bawlp'
self.client.heka(msgtype, **heka_args)
actual_msg = self._extract_full_msg()
heka_args.update({
'type': msgtype,
'env_version': self.client.env_version,
'heka_pid': os.getpid(),
'heka_hostname': socket.gethostname(),
'timestamp': actual_msg.timestamp
})
# Everything but the UUID should be identical
expected_msg = dict_to_msg(heka_args)
pbencoder = ProtobufEncoder()
h, actual_msg = decode_message(pbencoder.encode(actual_msg))
h, expected_msg = decode_message(pbencoder.encode(expected_msg))
expected_msg.uuid = ''
actual_msg.uuid = ''
eq_(actual_msg, expected_msg)
def test_heka_full(self):
heka_args = dict(payload='this is another test',
logger='alternate',
severity=2,
fields={'foo': 'bar',
'boo': 'far'})
msgtype = 'bawlp'
self.client.heka(msgtype, **heka_args)
actual_msg = self._extract_full_msg()
heka_args.update({'type': msgtype,
'env_version': self.client.env_version,
'heka_pid': os.getpid(),
'heka_hostname': socket.gethostname(),
'timestamp': actual_msg.timestamp})
# Everything but the UUID should be identical
expected_msg = dict_to_msg(heka_args)
pbencoder = ProtobufEncoder()
h, actual_msg = decode_message(pbencoder.encode(actual_msg))
h, expected_msg = decode_message(pbencoder.encode(expected_msg))
expected_msg.uuid = ''
actual_msg.uuid = ''
eq_(actual_msg, expected_msg)
def test_raven_method(self):
def exception_call2(a, b, c):
return a + b + c / (a - b)
def exception_call1(x, y):
return exception_call2(y, x, 42)
try:
exception_call1(5, 5)
except:
self.client.raven('some message')
eq_(1, len(self.client.stream.msgs))
h, msg = decode_message(self.client.stream.msgs[0])
rc = RavenClient()
sentry_fields = rc.decode(msg.payload)
eq_(sentry_fields['culprit'], 'test_heka in exception_call2')
eq_(len(sentry_fields['sentry.interfaces.Stacktrace']['frames']), 3)
eq_(sentry_fields['extra']['msg'], "'some message'")
eq_(msg.logger, '')
eq_(msg.type, 'sentry')
eq_(msg.severity, SEVERITY.ERROR)
f = [f for f in msg.fields if f.name == 'msg'][0]
eq_(f.value_string, ['some message'])
f = [f for f in msg.fields if f.name == 'dsn'][0]
eq_(f.value_string, [self.dsn])
def test_raven_method(self):
def exception_call2(a, b, c):
return a + b + c / (a - b)
def exception_call1(x, y):
return exception_call2(y, x, 42)
try:
exception_call1(5, 5)
except:
self.client.raven('some message')
eq_(1, len(self.client.stream.msgs))
h, msg = decode_message(self.client.stream.msgs[0])
rc = RavenClient()
sentry_fields = rc.decode(msg.payload)
eq_(sentry_fields['culprit'], 'test_heka in exception_call2')
eq_(len(sentry_fields['sentry.interfaces.Stacktrace']['frames']), 3)
eq_(sentry_fields['extra']['msg'], "'some message'")
eq_(msg.logger, '')
eq_(msg.type, 'sentry')
eq_(msg.severity, SEVERITY.ERROR)
f = [f for f in msg.fields if f.name == 'msg'][0]
eq_(f.value_string, ['some message'])
f = [f for f in msg.fields if f.name == 'dsn'][0]
eq_(f.value_string, [self.dsn])
def test_basic(self):
with Settings(HEKA_CONF=self.HEKA_CONF,
HEKA=self.HEKA,
SENTRY_CLIENT=self.SENTRY_CLIENT,
SENTRY_DSN=DSN):
self.raven = get_client()
self.raven.capture('Message', message='foo')
msgs = []
for mdata in settings.HEKA.stream.msgs:
h, m = decode_message(mdata)
msgs.append(m)
self.assertEquals(len(msgs), 1)
event = self.raven.decode(msgs[0].payload)
self.assertTrue('sentry.interfaces.Message' in event)
message = event['sentry.interfaces.Message']
self.assertEquals(message['message'], 'foo')
self.assertEquals(event['level'], logging.ERROR)
self.assertEquals(event['message'], 'foo')
# The project_id must be extracted from the SENTRY_DSN
# option
self.assertEquals(event['project'],
str(TESTING_PROJECT_ID))
# This is different than the regular Django test as we are
# *decoding* a serialized message - so instead of checking
# for datetime, we expect a string
self.assertTrue(isinstance(event['timestamp'], basestring))
def test_basic(self):
with Settings(HEKA_CONF=self.HEKA_CONF,
HEKA=self.HEKA,
SENTRY_CLIENT=self.SENTRY_CLIENT,
SENTRY_DSN=DSN):
self.raven = get_client()
self.raven.capture('Message', message='foo')
msgs = []
for mdata in settings.HEKA.stream.msgs:
h, m = decode_message(mdata)
msgs.append(m)
self.assertEquals(len(msgs), 1)
event = self.raven.decode(msgs[0].payload)
self.assertTrue('sentry.interfaces.Message' in event)
message = event['sentry.interfaces.Message']
self.assertEquals(message['message'], 'foo')
self.assertEquals(event['level'], logging.ERROR)
self.assertEquals(event['message'], 'foo')
# The project_id must be extracted from the SENTRY_DSN
# option
self.assertEquals(event['project'], str(TESTING_PROJECT_ID))
# This is different than the regular Django test as we are
# *decoding* a serialized message - so instead of checking
# for datetime, we expect a string
self.assertTrue(isinstance(event['timestamp'], basestring))
def test_logging_handler(self):
logger = logging.getLogger('demo')
hook_logger('demo', self.client)
msg = "this is an info message"
logger.info(msg)
# Need to decode the JSON encoded message
msgbytes = self.mock_stream.write.call_args[0][0]
h, m = decode_message(msgbytes)
eq_(msg, m.payload)
def test_logging_handler(self):
logger = logging.getLogger('demo')
hook_logger('demo', self.client)
msg = "this is an info message"
logger.info(msg)
# Need to decode the JSON encoded message
msgbytes = self.mock_stream.write.call_args[0][0]
h, m = decode_message(msgbytes)
eq_(msg, m.payload)
def _log(self, name, severity, *args, **kw):
# Capture the output from heka and clear the internal debug buffer
self.client.cef(name, severity, self.environ, self.config, *args, **kw)
msgs = self.client.stream.msgs
# Need to strip out protobuf header of 8 bytes
h, msg = decode_message(msgs[0])
msgs.clear()
# We only care about the CEF payload
assert msg.type == 'cef'
return msg.payload
def _log(self, name, severity, *args, **kw):
# Capture the output from heka and clear the internal debug buffer
self.client.cef(name, severity, self.environ, self.config, *args, **kw)
msgs = self.client.stream.msgs
# Need to strip out protobuf header of 8 bytes
h, msg = decode_message(msgs[0])
msgs.clear()
# We only care about the CEF payload
assert msg.type == 'cef'
return msg.payload
def test_hmac_signer_sha1(self):
hmac_signer = {'signer': 'vic',
'key_version': 1,
'hash_function': 'SHA1',
'key': 'some_key'}
enc = JSONEncoder(hmac_signer)
bytes = enc.encode(SAMPLE_MSG)
header, message = decode_message(bytes)
e1 = hmac.new(hmac_signer['key'],
enc.msg_to_payload(SAMPLE_MSG), sha1).digest()
eq_(header.hmac, e1)
def test_hmac_signer_md5(self):
hmac_signer = {'signer': 'vic',
'key_version': 1,
'hash_function': 'MD5',
'key': 'some_key'}
enc = ProtobufEncoder(hmac_signer)
bytes = enc.encode(SAMPLE_MSG)
header, message = decode_message(bytes)
payload = enc.msg_to_payload(SAMPLE_MSG)
e1 = hmac.new(hmac_signer['key'], payload, md5).digest()
eq_(header.hmac, e1)
def test_hmac_signer_md5(self):
hmac_signer = {'signer': 'vic',
'key_version': 1,
'hash_function': 'MD5',
'key': 'some_key'}
enc = ProtobufEncoder(hmac_signer)
bytes = enc.encode(SAMPLE_MSG)
header, message = decode_message(bytes)
payload = enc.msg_to_payload(SAMPLE_MSG)
e1 = hmac.new(hmac_signer['key'], payload, md5).digest()
eq_(header.hmac, e1)
def test_uuid_becomes_base64(self):
# Check that message decoding works symmetrically
enc = JSONEncoder()
heka_jdata = """{"uuid":"VTSIOf61R1yNDapwB8NzMw==","timestamp":1366901022982316037,"type":"TEST","logger":"GoSpec","severity":6,"payload":"Test Payload","env_version":"0.8","pid":16611,"hostname":"victorng-MacBookAir","fields":[{"name":"foo","value_type":"STRING","representation":"","value_string":["bar"]}]}"""
heka_msg = enc.decode(heka_jdata)
heka_bytes = enc.encode(heka_msg)
h, m = decode_message(heka_bytes)
eq_(m, heka_msg)
# Now double check that the msg going to json is the same
py_bytes = enc.encode(m)
eq_(json.loads(py_bytes[8:]), json.loads(heka_jdata))
eq_(base64.b64encode(heka_msg.uuid), json.loads(heka_jdata)['uuid'])
def test_hmac_signer_md5(self):
hmac_signer = {'signer': 'vic',
'key_version': 1,
'hash_function': 'MD5',
'key': 'some_key'}
enc = ProtobufEncoder(hmac_signer)
bytes = enc.encode(self.msg)
header, message = decode_message(bytes)
self.render(header.SerializeToString(), "Header bytes")
payload = enc.msg_to_payload(self.msg)
e1 = hmac.new(hmac_signer['key'], payload, md5).digest()
eq_(header.hmac, e1)
self.render(bytes, 'Full MD5 signed message')
self.render(header.hmac, 'md5 hmac')
def test_hmac_signer_md5(self):
hmac_signer = {
'signer': 'vic',
'key_version': 1,
'hash_function': 'MD5',
'key': 'some_key'
}
enc = ProtobufEncoder(hmac_signer)
bytes = enc.encode(self.msg)
header, message = decode_message(bytes)
self.render(header.SerializeToString(), "Header bytes")
payload = enc.msg_to_payload(self.msg)
e1 = hmac.new(hmac_signer['key'], payload, md5).digest()
eq_(header.hmac, e1)
self.render(bytes, 'Full MD5 signed message')
self.render(header.hmac, 'md5 hmac')
def test_signal_integration(self):
with Settings(HEKA_CONF=self.HEKA_CONF,
HEKA=self.HEKA,
SENTRY_CLIENT=self.SENTRY_CLIENT,
SENTRY_DSN=DSN):
self.raven = get_client()
try:
int('hello')
except:
got_request_exception.send(sender=self.__class__, request=None)
else:
self.fail('Expected an exception.')
msgs = []
for mdata in settings.HEKA.stream.msgs:
h, m = decode_message(mdata)
msgs.append(m)
self.assertEquals(len(msgs), 1)
event = self.raven.decode(msgs[0].payload)
self.assertTrue('sentry.interfaces.Exception' in event)
exc = event['sentry.interfaces.Exception']
self.assertEquals(exc['type'], 'ValueError')
self.assertEquals(
exc['value'],
u"invalid literal for int() with base 10: 'hello'")
self.assertEquals(event['level'], logging.ERROR)
self.assertEquals(
event['message'],
u"ValueError: invalid literal for int() with base 10: 'hello'")
self.assertEquals(
event['culprit'],
'tests.contrib.django.tests in test_signal_integration')
# The project_id must be extracted from the SENTRY_DSN
# option
self.assertEquals(event['project'], str(TESTING_PROJECT_ID))
def test_capture_stack(self):
###
def exception_call2(a, b, c):
return a + b + c / (a - b)
@capture_stack
def exception_call1(x, y):
return exception_call2(y, x, 42)
###
msgs = []
try:
exception_call1(5, 5)
except:
for mdata in self.client.stream.msgs:
h, msg = decode_message(mdata)
msgs.append(msg)
# There should be 1 exception
eq_(len(msgs), 1)
# We should have a culprit of exception_call2
event = msgs[0]
rc = RavenClient()
sentry_fields = rc.decode(event.payload)
eq_(sentry_fields['culprit'],
'test_heka in exception_call2')
frames = sentry_fields['sentry.interfaces.Stacktrace']['frames']
culprit_frame = [f for f in frames \
if f['function'] == 'exception_call2'][0]
# Check for the variables that cause the divide by zero
eq_(culprit_frame['vars']["'a'"],
culprit_frame['vars']["'b'"],
5)
eq_(event.severity, SEVERITY.ERROR)
def test_capture_stack(self):
###
def exception_call2(a, b, c):
return a + b + c / (a - b)
@capture_stack
def exception_call1(x, y):
return exception_call2(y, x, 42)
###
msgs = []
try:
exception_call1(5, 5)
except:
for mdata in self.client.stream.msgs:
h, msg = decode_message(mdata)
msgs.append(msg)
# There should be 1 exception
eq_(len(msgs), 1)
# We should have a culprit of exception_call2
event = msgs[0]
rc = RavenClient()
sentry_fields = rc.decode(event.payload)
eq_(sentry_fields['culprit'], 'test_heka in exception_call2')
frames = sentry_fields['sentry.interfaces.Stacktrace']['frames']
culprit_frame = [f for f in frames \
if f['function'] == 'exception_call2'][0]
# Check for the variables that cause the divide by zero
eq_(culprit_frame['vars']["'a'"], culprit_frame['vars']["'b'"], 5)
eq_(event.severity, SEVERITY.ERROR)
def test_signal_integration(self):
with Settings(HEKA_CONF=self.HEKA_CONF,
HEKA=self.HEKA,
SENTRY_CLIENT=self.SENTRY_CLIENT,
SENTRY_DSN=DSN):
self.raven = get_client()
try:
int('hello')
except:
got_request_exception.send(sender=self.__class__, request=None)
else:
self.fail('Expected an exception.')
msgs = []
for mdata in settings.HEKA.stream.msgs:
h, m = decode_message(mdata)
msgs.append(m)
self.assertEquals(len(msgs), 1)
event = self.raven.decode(msgs[0].payload)
self.assertTrue('sentry.interfaces.Exception' in event)
exc = event['sentry.interfaces.Exception']
self.assertEquals(exc['type'], 'ValueError')
self.assertEquals(exc['value'], u"invalid literal for int() with base 10: 'hello'")
self.assertEquals(event['level'], logging.ERROR)
self.assertEquals(event['message'], u"ValueError: invalid literal for int() with base 10: 'hello'")
self.assertEquals(event['culprit'],
'tests.contrib.django.tests in test_signal_integration')
# The project_id must be extracted from the SENTRY_DSN
# option
self.assertEquals(event['project'],
str(TESTING_PROJECT_ID))
def _extract_msg(self, bytes):
h, m = decode_message(bytes)
return m
def _extract_full_msg(self):
h, m = decode_message(self.mock_sender.msgs[0])
return m
def _extract_full_msg(self):
h, m = decode_message(self.stream.msgs[0])
return m
def test_explicit_payloads(self):
expected_payload="some payload data"
self.client.raven(payload=expected_payload)
eq_(1, len(self.client.stream.msgs))
h, msg = decode_message(self.client.stream.msgs[0])
eq_(msg.payload, expected_payload)
def _extract_msg(self, bytes):
h, m = decode_message(bytes)
return m
def _extract_full_msg(self):
h, m = decode_message(self.stream.msgs[0])
return m
def test_explicit_payloads(self):
expected_payload = "some payload data"
self.client.raven(payload=expected_payload)
eq_(1, len(self.client.stream.msgs))
h, msg = decode_message(self.client.stream.msgs[0])
eq_(msg.payload, expected_payload)
