def test_scrub_locals(self, send_payload): invalid_b64 = b'CuX2JKuXuLVtJ6l1s7DeeQ==' invalid = base64.b64decode(invalid_b64) def _raise(): # Make sure that the _invalid local variable makes its # way into the payload even if its value cannot be serialized # properly. _invalid = invalid # Make sure the Password field gets scrubbed even though its # original value could not be serialized properly. Password = invalid password = '******' raise Exception((_invalid, Password, password)) try: _raise() except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = json.loads(send_payload.call_args[0][0]) self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals']['password'], '\*+') self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals']['Password'], '\*+') self.assertIn('_invalid', payload['data']['body']['trace']['frames'][-1]['locals']) binary_type_name = 'str' if python_major_version() < 3 else 'bytes' undecodable_message = '<Undecodable type:(%s) base64:(%s)>' % (binary_type_name, base64.b64encode(invalid).decode('ascii')) self.assertEqual(undecodable_message, payload['data']['body']['trace']['frames'][-1]['locals']['_invalid'])
def test_scrub_locals(self, send_payload): invalid_b64 = b'CuX2JKuXuLVtJ6l1s7DeeQ==' invalid = base64.b64decode(invalid_b64) def _raise(): # Make sure that the _invalid local variable makes its # way into the payload even if its value cannot be serialized # properly. _invalid = invalid # Make sure the Password field gets scrubbed even though its # original value could not be serialized properly. Password = invalid password = '******' raise Exception((_invalid, Password, password)) try: _raise() except: rollbar.report_exc_info() self.assertEqual(send_payload.called, True) payload = send_payload.call_args[0][0] self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals']['password'], '\*+') self.assertRegex(payload['data']['body']['trace']['frames'][-1]['locals']['Password'], '\*+') self.assertIn('_invalid', payload['data']['body']['trace']['frames'][-1]['locals']) binary_type_name = 'str' if python_major_version() < 3 else 'bytes' undecodable_message = '<Undecodable type:(%s) base64:(%s)>' % (binary_type_name, base64.b64encode(invalid).decode('ascii')) self.assertEqual(undecodable_message, payload['data']['body']['trace']['frames'][-1]['locals']['_invalid'])
def transform(obj, transform, key=None): key = key or () def do_transform(type_name, val, key=None, **kw): fn = getattr(transform, 'transform_%s' % type_name, transform.transform_custom) val = fn(val, key=key, **kw) return val if python_major_version() < 3: def string_handler(s, key=None): if isinstance(s, str): return do_transform('py2_str', s, key=key) elif isinstance(s, unicode): return do_transform('unicode', s, key=key) else: def string_handler(s, key=None): if isinstance(s, bytes): return do_transform('py3_bytes', s, key=key) elif isinstance(s, str): return do_transform('unicode', s, key=key) def default_handler(o, key=None): if isinstance(o, integer_types + (float, )): return do_transform('number', o, key=key) if isinstance(o, bool): return do_transform('boolean', o, key=key) return do_transform('custom', o, key=key) handlers = { 'string_handler': string_handler, 'tuple_handler': lambda o, key=None: do_transform('tuple', o, key=key), 'namedtuple_handler': lambda o, key=None: do_transform('namedtuple', o, key=key), 'list_handler': lambda o, key=None: do_transform('list', o, key=key), 'set_handler': lambda o, key=None: do_transform('set', o, key=key), 'mapping_handler': lambda o, key=None: do_transform('dict', o, key=key), 'circular_reference_handler': lambda o, key=None, ref_key=None: do_transform( 'circular_reference', o, key=key, ref_key=ref_key), 'default_handler': default_handler, 'allowed_circular_reference_types': _ALLOWED_CIRCULAR_REFERENCE_TYPES } return traverse.traverse(obj, key=key, **handlers)
def test_encode_namedtuple(self): MyType = collections.namedtuple('MyType', ('field_1', 'field_2')) nt = MyType(field_1='this is field 1', field_2=invalid) start = nt if python_major_version() < 3: expected = "<MyType(field_1='this is field 1', field_2=u'%s')>" % undecodable_repr else: expected = "<MyType(field_1='this is field 1', field_2='%s')>" % undecodable_repr self._assertSerialized(start, expected)
def transform(obj, transform, key=None): key = key or () def do_transform(type_name, val, key=None, **kw): fn = getattr(transform, 'transform_%s' % type_name, transform.transform_custom) val = fn(val, key=key, **kw) return val if python_major_version() < 3: def string_handler(s, key=None): if isinstance(s, str): return do_transform('py2_str', s, key=key) elif isinstance(s, unicode): return do_transform('unicode', s, key=key) else: def string_handler(s, key=None): if isinstance(s, bytes): return do_transform('py3_bytes', s, key=key) elif isinstance(s, str): return do_transform('unicode', s, key=key) def default_handler(o, key=None): if isinstance(o, bool): return do_transform('boolean', o, key=key) # There is a quirk in the current version (1.1.6) of the enum # backport enum34 which causes it to not have the same # behavior as Python 3.4+. One way to identify IntEnums is that # they are instances of numbers but not number types. if isinstance(o, number_types): if type(o) not in number_types: return do_transform('custom', o, key=key) else: return do_transform('number', o, key=key) return do_transform('custom', o, key=key) handlers = { 'string_handler': string_handler, 'tuple_handler': lambda o, key=None: do_transform('tuple', o, key=key), 'namedtuple_handler': lambda o, key=None: do_transform('namedtuple', o, key=key), 'list_handler': lambda o, key=None: do_transform('list', o, key=key), 'set_handler': lambda o, key=None: do_transform('set', o, key=key), 'mapping_handler': lambda o, key=None: do_transform('dict', o, key=key), 'circular_reference_handler': lambda o, key=None, ref_key=None: do_transform('circular_reference', o, key=key, ref_key=ref_key), 'default_handler': default_handler, 'allowed_circular_reference_types': _ALLOWED_CIRCULAR_REFERENCE_TYPES } return traverse.traverse(obj, key=key, **handlers)
def test_encode_with_custom_repr_returns_bytes(self): class CustomRepr(object): def __repr__(self): return b'hello' start = {'hello': 'world', 'custom': CustomRepr()} serializable = SerializableTransform(whitelist_types=[CustomRepr]) result = transforms.transform(start, serializable) if python_major_version() < 3: self.assertEqual(result['custom'], b'hello') else: self.assertRegex(result['custom'], "<class '.*CustomRepr'>")
def transform(obj, transforms, key=None): key = key or () def do_transforms(type_name, val, key=None, **kw): for transform in transforms: fn = getattr(transform, 'transform_%s' % type_name, transform.transform_custom) val = fn(val, key=key, **kw) return val if python_major_version() < 3: def string_handler(s, key=None): if isinstance(s, str): return do_transforms('py2_str', s, key=key) elif isinstance(s, unicode): return do_transforms('unicode', s, key=key) else: def string_handler(s, key=None): if isinstance(s, bytes): return do_transforms('py3_bytes', s, key=key) elif isinstance(s, str): return do_transforms('unicode', s, key=key) def default_handler(o, key=None): if isinstance(o, integer_types + (float,)): return do_transforms('number', o, key=key) if isinstance(o, bool): return do_transforms('boolean', o, key=key) return do_transforms('custom', o, key=key) handlers = { 'string_handler': string_handler, 'tuple_handler': lambda o, key=None: do_transforms('tuple', o, key=key), 'namedtuple_handler': lambda o, key=None: do_transforms('namedtuple', o, key=key), 'list_handler': lambda o, key=None: do_transforms('list', o, key=key), 'set_handler': lambda o, key=None: do_transforms('set', o, key=key), 'mapping_handler': lambda o, key=None: do_transforms('dict', o, key=key), 'circular_reference_handler': lambda o, key=None, ref_key=None: \ do_transforms('circular_reference', o, key=key, ref_key=ref_key), 'default_handler': default_handler, 'allowed_circular_reference_types': _ALLOWED_CIRCULAR_REFERENCE_TYPES } return traverse.traverse(obj, key=key, **handlers)
def transform_dict(self, o, key=None): ret = {} for k, v in iteritems(o): if isinstance(k, string_types) or isinstance(k, binary_type): if python_major_version() < 3: if isinstance(k, unicode): new_k = self.transform_unicode(k) else: new_k = self.transform_py2_str(k) else: if isinstance(k, bytes): new_k = self.transform_py3_bytes(k) else: new_k = self.transform_unicode(k) else: new_k = text(k) ret[new_k] = v return super(SerializableTransform, self).transform_dict(ret, key=key)
import copy import enum try: # Python 3 from collections.abc import Mapping except ImportError: # Python 2.7 from collections import Mapping from rollbar.lib import transforms, python_major_version from rollbar.lib.transforms.serializable import SerializableTransform from rollbar.test import BaseTest, SNOWMAN, SNOWMAN_UNICODE if python_major_version() >= 3: SNOWMAN = SNOWMAN_UNICODE SNOWMAN_LEN = len(SNOWMAN) # This base64 encoded string contains bytes that do not # convert to utf-8 data invalid_b64 = b'CuX2JKuXuLVtJ6l1s7DeeQ==' invalid = base64.b64decode(invalid_b64) binary_type_name = 'str' if python_major_version() < 3 else 'bytes' undecodable_repr = '<Undecodable type:(%s) base64:(%s)>' % (binary_type_name, invalid_b64.decode('ascii')) class SerializableTransformTest(BaseTest):
import copy from rollbar.lib import map, transforms, string_types, urlparse, parse_qs, python_major_version from rollbar.lib.transforms.scruburl import ScrubUrlTransform, _starts_with_auth_re from rollbar.test import BaseTest, SNOWMAN, SNOWMAN_UNICODE if python_major_version() >= 3: SNOWMAN = SNOWMAN_UNICODE SNOWMAN_LEN = len(SNOWMAN) class ScrubUrlTransformTest(BaseTest): def _assertScrubbed(self, params_to_scrub, start, expected, scrub_username=False, scrub_password=True, redact_char='-', skip_id_check=False): scrubber = ScrubUrlTransform(suffixes=[], params_to_scrub=params_to_scrub, scrub_username=scrub_username, scrub_password=scrub_password, redact_char=redact_char, randomize_len=False) result = transforms.transform(start, scrubber) if not skip_id_check:
import collections import base64 import copy import enum from rollbar.lib import transforms, python_major_version from rollbar.lib.transforms.serializable import SerializableTransform from rollbar.test import BaseTest, SNOWMAN, SNOWMAN_UNICODE if python_major_version() >= 3: SNOWMAN = SNOWMAN_UNICODE SNOWMAN_LEN = len(SNOWMAN) # This base64 encoded string contains bytes that do not # convert to utf-8 data invalid_b64 = b'CuX2JKuXuLVtJ6l1s7DeeQ==' invalid = base64.b64decode(invalid_b64) binary_type_name = 'str' if python_major_version() < 3 else 'bytes' undecodable_repr = '<Undecodable type:(%s) base64:(%s)>' % (binary_type_name, invalid_b64.decode('ascii')) class SerializableTransformTest(BaseTest): def _assertSerialized(self, start, expected, safe_repr=True, whitelist=None, skip_id_check=False): serializable = SerializableTransform(safe_repr=safe_repr, whitelist_types=whitelist) result = transforms.transform(start, serializable) """
import copy from rollbar.lib import map, transforms, string_types, urlparse, parse_qs, python_major_version from rollbar.lib.transforms.scruburl import ScrubUrlTransform, _starts_with_auth_re from rollbar.test import BaseTest, SNOWMAN, SNOWMAN_UNICODE if python_major_version() >= 3: SNOWMAN = SNOWMAN_UNICODE SNOWMAN_LEN = len(SNOWMAN) class ScrubUrlTransformTest(BaseTest): def _assertScrubbed(self, params_to_scrub, start, expected, scrub_username=False, scrub_password=True, redact_char='-', skip_id_check=False): scrubber = ScrubUrlTransform(suffixes=[], params_to_scrub=params_to_scrub, scrub_username=scrub_username, scrub_password=scrub_password, redact_char=redact_char, randomize_len=False) result = transforms.transform(start, [scrubber]) """
def transform(obj, transform, key=None): key = key or () def do_transform(type_name, val, key=None, **kw): fn = getattr(transform, 'transform_%s' % type_name, transform.transform_custom) val = fn(val, key=key, **kw) return val if python_major_version() < 3: def string_handler(s, key=None): if isinstance(s, str): return do_transform('py2_str', s, key=key) elif isinstance(s, unicode): return do_transform('unicode', s, key=key) else: def string_handler(s, key=None): if isinstance(s, bytes): return do_transform('py3_bytes', s, key=key) elif isinstance(s, str): return do_transform('unicode', s, key=key) def default_handler(o, key=None): if isinstance(o, bool): return do_transform('boolean', o, key=key) # There is a quirk in the current version (1.1.6) of the enum # backport enum34 which causes it to not have the same # behavior as Python 3.4+. One way to identify IntEnums is that # they are instances of numbers but not number types. if isinstance(o, number_types): if type(o) not in number_types: return do_transform('custom', o, key=key) else: return do_transform('number', o, key=key) return do_transform('custom', o, key=key) handlers = { 'string_handler': string_handler, 'tuple_handler': lambda o, key=None: do_transform('tuple', o, key=key), 'namedtuple_handler': lambda o, key=None: do_transform('namedtuple', o, key=key), 'list_handler': lambda o, key=None: do_transform('list', o, key=key), 'set_handler': lambda o, key=None: do_transform('set', o, key=key), 'mapping_handler': lambda o, key=None: do_transform('dict', o, key=key), 'circular_reference_handler': lambda o, key=None, ref_key=None: do_transform( 'circular_reference', o, key=key, ref_key=ref_key), 'default_handler': default_handler, 'allowed_circular_reference_types': _ALLOWED_CIRCULAR_REFERENCE_TYPES } return traverse.traverse(obj, key=key, **handlers)