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_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 _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_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_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 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)