def test_runloop_execute(self):
        from asset_folder_importer.fix_unattached_media import reattach_thread
        from Queue import PriorityQueue
        from raven import Client
        
        q = PriorityQueue()
        
        fake_client = Client('https://1234:[email protected]/1')
        fake_client.captureException = mock.MagicMock()
        logger = logging.getLogger("test_runloop")
        logger.debug = mock.MagicMock()
        logger.error = mock.MagicMock()
        logger.info = mock.MagicMock()
        logger.warning = mock.MagicMock()
        
        rat = reattach_thread.ReattachThread(q, options=None, raven_client=fake_client, timeout=2,
                                             logger=logger, should_raise=True)
        q.put((1, {'itemid': 'KP-1234', 'collectionid': 'KP-5678'}))
        rat.reattach = mock.MagicMock()
        
        rat.run()

        rat.reattach.assert_called_with('KP-1234', 'KP-5678')
        logger.error.assert_called_with("Input queue timed out, exiting.")
        logger.info.assert_called_with("Reattach thread terminating")

 def connect_sentry(result):
     pillar_data = __salt__['pillar.raw']()
     sentry_data = {
         'result': result,
         'returned': ret,
         'pillar': pillar_data,
         'grains': __salt__['grains.items']()
     }
     servers = []
     try:
         for server in pillar_data['raven']['servers']:
             servers.append(server + '/api/store/')
         client = Client(
             servers=servers,
             public_key=pillar_data['raven']['public_key'],
             secret_key=pillar_data['raven']['secret_key'],
             project=pillar_data['raven']['project'],
         )
     except KeyError as missing_key:
         logger.error("Sentry returner need config '%s' in pillar",
                      missing_key)
     else:
         try:
             client.captureMessage(ret['comment'], extra=sentry_data)
         except Exception as err:
             logger.error("Can't send message to sentry: %s", err,
                          exc_info=True)

def lights433(host, port, adapter, adapter_args, switches, sentry):

    sentry_client, sentry_url = None, None
    if sentry or os.path.exists(DEFAULT_SENTRY_CONF):
        sentry = sentry if sentry is not None else DEFAULT_SENTRY_CONF
        with open(sentry, 'r') as f:
            sentry_url = f.read().strip()
        if not sentry_url:
            log.error("No sentry URL specified in [%s]" % sentry)
            sys.exit(1)
        else:
            sentry_client = Client(sentry_url)
            log.info("Sentry client configured!")

    try:
        log.info("Loading switch configurations from [%s]" % switches)

        adapter_kwargs = dict(
            pair.split('=') for pair in adapter_args.split(',')
        )

        adapter = get_adapter(adapter)(**adapter_kwargs)
        server = Lights433Server(host, port, adapter, switches)
    except:
        if sentry_client:
            sentry_client.captureException()
        raise

    if sentry_client:
        Sentry(dsn=sentry_url).init_app(server.app)
    server.run()

def main():
    root = logging.getLogger('sentry.errors')
    root.setLevel(logging.DEBUG)
    root.addHandler(logging.StreamHandler())

    dsn = ' '.join(sys.argv[2:])
    if not (dsn or os.environ.get('SENTRY_DSN')):
        print "Error: No configuration detected!"
        print "You must either pass a DSN to the command, or set the SENTRY_DSN environment variable."
        sys.exit(1)

    print "Using DSN configuration:"
    print " ", dsn
    print

    client = Client(dsn)

    print "Client configuration:"
    for k in ('servers', 'project', 'public_key', 'secret_key'):
        print '  %-15s: %s' % (k, getattr(client, k))
    print

    if not all([client.servers, client.project, client.public_key, client.secret_key]):
        print "Error: All values must be set!"
        sys.exit(1)

    print 'Sending a test message...',
    ident = client.get_ident(client.captureMessage('This is a test message generated using ``raven test``'))
    print 'success!'
    print
    print 'The test message can be viewed at the following URL:'
    url = client.servers[0].split('/api/store/', 1)[0]
    print '  %s/%s/search/?q=%s' % (url, client.project, ident)

    def main(self):
        # consume standard input early
        lines = []
        p = re.compile("Subject: Cron <[^@][email protected][^ ]+> (.*)")
        mail_subject = 'This mail has no subject.'
        for line in sys.stdin:
            line = line.rstrip()
            lines.append(line)
            if line.startswith('Subject:'):
                mail_subject = line
                # Removes hostname from cron subject to aggregate sentry events
                if p.search(line):
                    cron_subject = p.search(line).group(1)
                    mail_subject = "Subject: Cron {0}".format(cron_subject)

        body = os.linesep.join(lines)
        if not len(body):
            sys.stderr.write("Empty stdin, nothing to report")
            sys.stderr.write(os.linesep)
            sys.exit(1)

        # init raven quickly, so if something is wrong it get logged early
        from raven import Client
        dsn = self.config['sentry_dsn']
        if not dsn.startswith("requests+"):
            dsn = "requests+" + dsn
        client = Client(dsn=dsn)

        if self.config['subject']:
            subject = self.config['subject']
        else:
            subject = mail_subject
        msg = os.linesep.join((subject, body))
        client.captureMessage(msg, extra=os.environ)

    def run_from_argv(self, argv):
        if len(argv) <= 2 or argv[2] in ['-h', '--help']:
            print self.usage(argv[1])
            sys.exit(1)

        subcommand_class = self._get_subcommand_class(argv[2])
        parser = self.create_parser(argv[0], argv[2], subcommand_class)
        if hasattr(self, 'use_argparse') and self.use_argparse:
            subcommand_class.add_arguments(parser)
            options = parser.parse_args(argv[3:])
            cmd_options = vars(options)
            args = cmd_options.pop('args', ())
        else:
            options, args = parser.parse_args(argv[3:])
        handle_default_options(options)
        try:
            subcommand_class.execute(*args, **options.__dict__)
        except Exception as e:
            if not isinstance(e, CommandError):
                if hasattr(settings, 'SENTRY_DSN'):
                    dsn = settings.SENTRY_DSN
                elif hasattr(settings, 'RAVEN_CONFIG'):
                    dsn = settings.RAVEN_CONFIG.get('dsn')
                else:
                    raise
                sentry = Client(dsn)
                # Force sync transport to avoid race condition with the process exiting
                for url in sentry.servers:
                    parsed = urlparse.urlparse(url)
                    transport = sentry._registry.get_transport(parsed)
                    transport.async = False
                sentry.get_ident(sentry.captureException())

            self._write_error_in_stderr(e)

class SentryMiddleware(Sentry):
    """
    As raven.middleware.Sentry doesn't really do what we need, we build our
    own. It merely extends Sentry in order to reuse the get_http_context
    method.
    """

    def __init__(self, app, config):
        self.app = app

        dsn = aconfig.get('adhocracy.sentry.dsn', config=config)
        if not dsn:
            raise Exception(
                'Sentry misconfigured. Please add adhocracy.sentry.dsn '
                'to your adhocracy config.')

        self.client = Client(dsn)

        handler = SentryHandler(
            self.client, level=aconfig.get('adhocracy.sentry.loglevel'))
        setup_logging(handler)

    def __call__(self, environ, start_response):
        self.client.tags_context({'version': version.get_version()})
        self.client.http_context(self.get_http_context(environ))
        return self.app(environ, start_response)

class PyLogConf (PyLog):
    def __init__ (self, conf):
        self.conf = conf
        self.client = Client (conf.RAVEN['dsn'])
        self.formatters = {}
        for k,v in self.conf.FILE_FORMATTERS.iteritems():
            if isinstance(v,str):
                raise ValueError ('Please use a list or a tuple for the file formatters values')
            self.formatters[k] = [item_import(i)() for i in v]
        dbname = os.path.join(os.path.dirname(conf.__file__),'pylogwatch.db')
        return super(PyLogConf, self).__init__ (self.conf.FILE_FORMATTERS.keys(), dbname = dbname)

    def get_file_signature(self, fname):
        maxcount = 10
        count = 0
        result = []
        with open(fname) as f:
            while count < maxcount:
                result.append(f.readline())
                count+=1
        return result

    def process_lines (self, fname, lines):
        for line in lines:
            paramdict = {}
            data = {'event_type':'Message', 'message': line.replace('%','%%'), 'data' :{'logger':fname}}
            for fobj in self.formatters[fname]:
                fobj.format_line(line, data, paramdict)
            if not data.get('do_not_send', False):
                if paramdict:
                    data['params'] = tuple([paramdict[i] for i in sorted(paramdict.keys())])
                if self.conf.DEBUG:
                    print data
                self.client.capture(**data)

    def process(self, record):
        if match_record(self.rules_tree, record):
            dsn = self.dsns.get(record.application)
            if dsn is None:
                projects = requests.get("%s/api/0/projects/" % self.url,
                                        auth=self.auth).json()
                for project in projects:
                    if project["name"] == record.application:
                        break
                else:
                    project = requests.post("%s/api/0/teams/%s/%s/projects/" % (self.url,
                                                                                self.organization,
                                                                                self.team),
                                            auth=self.auth,
                                            headers={"Content-type": "application/json"},
                                            data=json.dumps({"name": record.application})).json()

                for key in requests.get("%s/api/0/projects/%s/%s/keys/" % (self.url,
                                                                           self.organization,
                                                                           project["slug"]),
                                        auth=self.auth).json():
                    dsn = key["dsn"]["secret"]
                    self.dsns[record.application] = dsn

            client = Client(dsn, raise_send_errors=True)
            client.capture("raven.events.Message",
                           message=record.msg,
                           formatted=record.explanation or record.msg,
                           data={"logger": record.logger},
                           date=record.datetime,
                           extra=record._asdict())

 def send_to_sentry(self):
     """
     Send this error to sentry where it will be stored and aggregated.
     """
     print self.stack_trace
     log_level = self.log_level
     filename = get_filename(self.js_url)
     
     data={
         filename: {
             'url': self.js_url,
             'data': {},
             'query_string': '...',
             'method': 'POST',
         },
         'logger': 'front_end',
         'site': 'site.name',
     }
     
     if self.extra:
         data.update({"extra": json.loads(self.extra)})
             
     client = Client(settings.SENTRY_DSN)
     client.capture(
         "Message",
         message=self.message,
         data=data,
     )

def error_trigger(request):
    context = {}
    if request.method == 'POST':
        form = forms.TriggerErrorForm(request.POST)
        if form.is_valid():
            if form.cleaned_data['capture_with_raven']:
                try:
                    dsn = settings.RAVEN_CONFIG['dsn']
                except AttributeError:
                    messages.error(
                        request,
                        "No settings.RAVEN_CONFIG['dsn'] set up"
                    )
                    return redirect('manage:error_trigger')

                client = Client(dsn)
                try:
                    raise NameError(form.cleaned_data['message'])
                except NameError:
                    messages.info(
                        request,
                        str(client.captureException())
                    )
                return redirect('manage:error_trigger')

            raise NameError(
                'MANUAL ERROR TRIGGER: %s' % form.cleaned_data['message']
            )
    else:
        form = forms.TriggerErrorForm()

    context['form'] = form

    return render(request, 'manage/error_trigger.html', context)

class SentryPlugin(object):
    name = 'sentry'

    def __init__(self, dsn, **kwargs):
        self.client = None
        self.kwargs = kwargs
        self.dsn = dsn

    def setup(self,app):
        for other in app.plugins:
            if not isinstance(other, SentryPlugin):
                continue
        if self.client is None:
            self.client = Client(self.dsn, **self.kwargs)

    def apply(self,callback,context):
        def wrapper(*args,**kwargs):
            try:
                rv = callback(*args, **kwargs)
            except Exception, e:
                if not isinstance(e, HTTPError):
                    self.client.captureException()
                raise
            return rv
        return wrapper

    def run_from_argv(self, argv):
        if len(argv) <= 2 or argv[2] in ['-h', '--help']:
            stdout = OutputWrapper(sys.stdout)
            stdout.write(self.usage(argv[1]))
            sys.exit(1)

        subcommand_class = self._get_subcommand_class(argv[2])
        parser = self.create_parser(argv[0], argv[2], subcommand_class)
        if hasattr(self, 'use_argparse') and self.use_argparse:
            subcommand_class.add_arguments(parser)
            options = parser.parse_args(argv[3:])
            cmd_options = vars(options)
            args = cmd_options.pop('args', ())
        else:
            options, args = parser.parse_args(argv[3:])
        handle_default_options(options)
        try:
            subcommand_class.execute(*args, **options.__dict__)
        except Exception as e:
            if not isinstance(e, CommandError):
                if hasattr(settings, 'SENTRY_DSN'):
                    dsn = settings.SENTRY_DSN
                elif hasattr(settings, 'RAVEN_CONFIG'):
                    dsn = settings.RAVEN_CONFIG.get('dsn')
                else:
                    raise
                sentry = Client(dsn)
                if not sentry.is_enabled():
                    raise
                sentry.get_ident(sentry.captureException())

            self._write_error_in_stderr(e)

def connect_to_sentry() -> RavenClient:
    """Connect to Sentry and enable sys hook for pyinstaller failures"""
    with open("sentry") as fi:
        link = fi.read().strip()
    raven = RavenClient(link)
    raven.install_sys_hook()
    return raven

    def handle(self, *args, **kwargs):
        if args:
            pk = args[0]
            feed = UniqueFeed.objects.get(pk=pk)
            return update_feed(feed.url, use_etags=False)

        # This command is run every 5 minutes. Don't queue more than
        # 5/45 = a ninth of the total number of feeds.
        limit = UniqueFeed.objects.count() / 9

        uniques = UniqueFeed.objects.filter(
            muted=False,
        ).order_by('last_update')[:limit]

        for unique in uniques:
            try:
                if unique.should_update():
                    enqueue(update_feed, unique.url, timeout=20)
            except Exception:  # We don't know what to expect, and anyway
                               # we're reporting the exception
                if settings.DEBUG or not hasattr(settings, 'SENTRY_DSN'):
                    raise
                else:
                    client = Client(dsn=settings.SENTRY_DSN)
                    client.captureException()
        connection.close()

 def save(self, *a, **k):
     """
     Don't save to the database, send to sentry instead.
     """
     log_level = self.log_level
     filename = get_filename(self.js_url)
     
     data={
         filename: {
             'url': self.js_url,
             'data': {},
             'query_string': '...',
             'method': 'POST',
         },
         'logger': 'front_end',
         'site': 'site.name',
     }
     
     if self.extra:
         data.update({"extra": json.loads(self.extra)})
             
     client = Client(settings.SENTRY_DSN)
     client.capture(
         "Message",
         message=self.message,
         data=data,
     )

    def process_jobs(self, beanstalk):
        while True:
            logger.debug("Beanstalk connection established, waiting for jobs")
            job = beanstalk.reserve()
            job_name = job.stats()["tube"]
            if job_name in self.jobs:
                logger.debug("Calling %s with arg: %s" % (job_name, job.body))
                try:
                    connection = db.connections["default"]
                    if connection.connection:
                        try:
                            connection.connection.ping()
                        except OperationalError as e:
                            connection.close()

                    flush_transaction()
                    self.jobs[job_name](job.body)
                except Exception, e:
                    tp, value, tb = sys.exc_info()
                    logger.error('Error while calling "%s" with arg "%s": ' "%s" % (job_name, job.body, e))
                    logger.debug("%s:%s" % (tp.__name__, value))
                    logger.debug("\n".join(traceback.format_tb(tb)))

                    client = Client(dsn=settings.RAVEN_CONFIG["dsn"])
                    client.captureMessage(str(e), stack=True, level=logging.ERROR)

                    job.bury()
                else:
                    job.delete()
            else:
                job.release()

class PyLogConf (PyLog):
    def __init__ (self, conf):
        """
        Initialize object based on the provided configuration
        """
        self.conf = conf
        self.client = Client (conf.RAVEN['dsn'])
        self.formatters = {}
        for k,v in self.conf.FILE_FORMATTERS.iteritems():
            if isinstance(v,str):
                raise ValueError ('Please use a list or a tuple for the file formatters values')
            self.formatters[k] = [item_import(i)() for i in v]
        dbname = os.path.join(os.path.dirname(conf.__file__),'pylogwatch.db')
        return super(PyLogConf, self).__init__ (self.conf.FILE_FORMATTERS.keys(), dbname = dbname)

    def process_lines (self, fname, fileobject, lines):
        """Main workhorse. Called with the filename that is being logged and an iterable of lines"""
        for line in lines:
            paramdict = {}
            data = {'event_type':'Message', 'message': line.replace('%','%%'), 'data' :{'logger':fname}}
            for fobj in self.formatters[fname]:
                fobj.format_line(line, data, paramdict)
            if not data.pop('_do_not_send', False): # Skip lines that have the '_do_not_send' key
                if paramdict:
                    data['params'] = tuple([paramdict[i] for i in sorted(paramdict.keys())])
                if self.conf.DEBUG:
                    print data
                self.client.capture(**data)
                self.update_bytes(fname, fileobject.tell())

def main():
    root = logging.getLogger('sentry.errors')
    root.setLevel(logging.DEBUG)
    root.addHandler(logging.StreamHandler())

    parser = OptionParser()
    parser.add_option("--data", action="callback", callback=store_json,
                      type="string", nargs=1, dest="data")
    (opts, args) = parser.parse_args()

    dsn = ' '.join(args[1:]) or os.environ.get('SENTRY_DSN')
    if not dsn:
        print "Error: No configuration detected!"
        print "You must either pass a DSN to the command, or set the SENTRY_DSN environment variable."
        sys.exit(1)

    print "Using DSN configuration:"
    print " ", dsn
    print

    client = Client(dsn, include_paths=['raven'])

    print "Client configuration:"
    for k in ('servers', 'project', 'public_key', 'secret_key'):
        print '  %-15s: %s' % (k, getattr(client, k))
    print

    if not all([client.servers, client.project, client.public_key, client.secret_key]):
        print "Error: All values must be set!"
        sys.exit(1)

    print 'Sending a test message...',
    ident = client.get_ident(client.captureMessage(
        message='This is a test message generated using ``raven test``',
        data=opts.data or {
            'culprit': 'raven.scripts.runner',
            'logger': 'raven.test',
            'sentry.interfaces.Http': {
                'method': 'GET',
                'url': 'http://example.com',
            }
        },
        level=logging.INFO,
        stack=True,
        extra={
            'user': pwd.getpwuid(os.geteuid())[0],
            'loadavg': os.getloadavg(),
        }
    ))

    if client.state.did_fail():
        print 'error!'
        return False

    print 'success!'
    print
    print 'The test message can be viewed at the following URL:'
    url = client.servers[0].split('/api/store/', 1)[0]
    print '  %s/%s/search/?q=%s' % (url, client.project, ident)

 def __init__(self, sentry_dsn, descriptor=None, data_limit=100, sentry_client_kwargs=None):
     
     if sentry_client_kwargs:
         self.sentry_client = SentryClient(dsn=sentry_dsn, **sentry_client_kwargs)
     else:
         self.sentry_client = SentryClient(dsn=sentry_dsn)
         
     super(ErrorSentry, self).__init__(descriptor=descriptor, data_limit=data_limit)