def test_simple():
    stack = TransactionStack()

    stack.push('foo')

    assert len(stack) == 1
    assert stack.peek() == 'foo'

    bar = stack.push(['bar'])

    assert len(stack) == 2
    assert stack.peek() == ['bar']

    stack.push({'baz': True})

    assert len(stack) == 3
    assert stack.peek() == {'baz': True}

    stack.pop(bar)

    assert len(stack) == 1
    assert stack.peek() == 'foo'

    stack.pop()

    assert len(stack) == 0
    assert stack.peek() == None
def test_context_manager():
    stack = TransactionStack()

    with stack('foo'):
        assert stack.peek() == 'foo'

    assert stack.peek() is None
Ejemplo n.º 3
0
    def __init__(self,
                 dsn=None,
                 raise_send_errors=False,
                 transport=None,
                 install_sys_hook=True,
                 install_logging_hook=True,
                 hook_libraries=None,
                 enable_breadcrumbs=True,
                 _random_seed=None,
                 **options):
        global Raven

        o = options

        self._local_state = local()

        self.raise_send_errors = raise_send_errors

        # configure loggers first
        cls = self.__class__
        self.state = ClientState()
        self.logger = logging.getLogger('%s.%s' %
                                        (cls.__module__, cls.__name__))
        self.error_logger = logging.getLogger('sentry.errors')
        self.uncaught_logger = logging.getLogger('sentry.errors.uncaught')

        self._transport_cache = {}
        self.set_dsn(dsn, transport)

        self.include_paths = set(o.get('include_paths') or [])
        self.exclude_paths = set(o.get('exclude_paths') or [])
        self.name = text_type(
            o.get('name') or o.get('machine') or defaults.NAME)
        self.auto_log_stacks = bool(
            o.get('auto_log_stacks') or defaults.AUTO_LOG_STACKS)
        self.capture_locals = bool(
            o.get('capture_locals', defaults.CAPTURE_LOCALS))
        self.string_max_length = int(
            o.get('string_max_length') or defaults.MAX_LENGTH_STRING)
        self.list_max_length = int(
            o.get('list_max_length') or defaults.MAX_LENGTH_LIST)
        self.site = o.get('site')
        self.include_versions = o.get('include_versions', True)
        self.processors = o.get('processors')
        if self.processors is None:
            self.processors = defaults.PROCESSORS

        context = o.get('context')
        if context is None:
            context = {'sys.argv': getattr(sys, 'argv', [])[:]}
        self.extra = context
        self.tags = o.get('tags') or {}
        self.environment = o.get('environment') or None
        self.release = o.get('release') or os.environ.get('HEROKU_SLUG_COMMIT')
        self.repos = self._format_repos(o.get('repos'))
        self.sample_rate = (o.get('sample_rate')
                            if o.get('sample_rate') is not None else 1)
        self.transaction = TransactionStack()
        self.ignore_exceptions = set(o.get('ignore_exceptions') or ())

        self.module_cache = ModuleProxyCache()

        self._random = Random(_random_seed)

        if not self.is_enabled():
            self.logger.info(
                'Raven is not configured (logging is disabled). Please see the'
                ' documentation for more information.')

        if Raven is None:
            Raven = self

        # We want to remember the creating thread id here because this
        # comes in useful for the context special handling
        self.main_thread_id = get_thread_ident()
        self.enable_breadcrumbs = enable_breadcrumbs

        from raven.context import Context
        self._context = Context(self)

        if install_sys_hook:
            self.install_sys_hook()

        if install_logging_hook:
            self.install_logging_hook()

        self.hook_libraries(hook_libraries)