Python Client.tags_context方法代码示例

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import tags_context [as 别名]
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)

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import tags_context [as 别名]
def setup_logging(logfile=None):
    amon_logger = logging.getLogger('amon')
    if logfile:
        hdlr = logging.FileHandler(logfile)
        formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
        hdlr.setFormatter(formatter)
        amon_logger.addHandler(hdlr)
    sentry = Client()
    sentry.tags_context({'version': VERSION})
    sentry_handler = SentryHandler(sentry, level=logging.ERROR)
    amon_logger.addHandler(sentry_handler)
    amon_logger.info('Amon logger setup')

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import tags_context [as 别名]
def setup_logging(logfile=None):
    log_config = config_from_environment('LOG')
    if log_config:
        logging.basicConfig(**log_config)
    logger = logging.getLogger('atr')
    if logfile:
        handler = logging.FileHandler(logfile)
        formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
    sentry = Client()
    sentry.tags_context({'version': VERSION})
    sentry_handler = SentryHandler(sentry, level=logging.ERROR)
    logger.addHandler(sentry_handler)
    logger.debug('ATR Logging setup done')

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import tags_context [as 别名]
def setup_logging(level=None, logfile=None):
    """
    Setups sippers logging system.

    It will setup sentry logging if SENTRY_DSN environment is defined

    :param level: logging.LEVEL to set to logger (defaults INFO)
    :param logfile: File to write the log
    :return: logger
    """
    stream = logging.StreamHandler()
    stream.setFormatter(logging.Formatter(LOG_FORMAT))

    logger = logging.getLogger('sippers')
    del logger.handlers[:]
    logger.addHandler(stream)

    if logfile:
        hdlr = logging.FileHandler(logfile)
        formatter = logging.Formatter(LOG_FORMAT)
        hdlr.setFormatter(formatter)
        logger.addHandler(hdlr)

    sentry = SentryClient()
    sentry.tags_context({'version': VERSION})
    sentry_handler = SentryHandler(sentry, level=logging.ERROR)
    logger.addHandler(sentry_handler)

    if isinstance(level, basestring):
        level = getattr(logging, level.upper(), None)

    if level is None:
        level = logging.INFO

    logger.setLevel(level)

    return logger

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import tags_context [as 别名]
class INV():
    def __init__(self, **kwargs):
        self.codi_r1 = kwargs.pop('codi_r1')
        self.base_object = 'Inventari'
        self.report_name = 'CNMC INVENTARI XML'
        self.liniesat = kwargs.pop('liniesat')
        self.liniesbt = kwargs.pop('liniesbt')
        self.subestacions = kwargs.pop('subestacions')
        self.posicions = kwargs.pop('posicions')
        self.maquinas = kwargs.pop('maquinas')
        self.despatxos = kwargs.pop('despatxos')
        self.fiabilidad = kwargs.pop('fiabilidad')
        self.transformacion = kwargs.pop('transformacion')
        self.file_out = kwargs.pop('output')
        self.pla_inversions_xml = cnmc_inventari.Empresa(self.codi_r1)
        if 'SENTRY_DSN' in os.environ and Client:
            self.raven = Client()
            self.raven.tags_context({'version': VERSION})
        else:
            self.raven = None

    def check_encoding(self):
        input_files = ['liniesat', 'liniesbt', 'subestacions', 'posicions',
                       'maquinas', 'despatxos', 'fiabilidad', 'transformacion']
        for input_f in input_files:
            with open(getattr(self, input_f), 'r') as f:
                result = detect(f.read())
                if result['encoding'] not in ('utf-8', 'ascii'):
                    raise Exception('File: %s is not in UTF-8.' % input_f)

    def open_csv_file(self, csv_file):
        reader = csv.reader(open(csv_file), delimiter=';')
        return reader

    def tractar_linies(self, arxiucsvlinies):
        reader = self.open_csv_file(arxiucsvlinies)
        for row in reader:
            if not row:
                continue
            linia = cnmc_inventari.Linea()

            identificador = row[0]
            cini = row[1]
            origen = row[2]
            destino = row[3]
            codigo_tipo_linea = row[4]
            codigo_ccaa_1 = row[5]
            codigo_ccaa_2 = row[6]
            participacion = row[7]
            fecha_aps = row[8]
            fecha_baja = row[9]
            numero_circuitos = row[10]
            numero_conductores = row[11]
            longitud = row[12]
            seccion = row[13]
            capacidad = row[14]

            linia.feed({
                'identificador': '%s' % identificador.strip(),
                'cini': '%s' % cini.strip(),
                'origen': '%s' % origen.strip(),
                'destino': '%s' % destino.strip(),
                'codigo_tipo_linea': '%s' % codigo_tipo_linea,
                'codigo_ccaa_1': '%s' % codigo_ccaa_1,
                'codigo_ccaa_2': '%s' % codigo_ccaa_2,
                'participacion': '%s' % participacion,
                'fecha_aps': '%s' % fecha_aps.strip(),
                'fecha_baja': '%s' % fecha_baja.strip(),
                'numero_circuitos': '%s' % numero_circuitos,
                'numero_conductores': '%s' % numero_conductores,
                'longitud': '%s' % longitud,
                'seccion': '%s' % seccion,
                'capacidad': '%s' % capacidad
            })
            self.pla_inversions_xml.linea.append(linia)

    def tractar_linies_at(self):
        self.tractar_linies(self.liniesat)

    def tractar_linies_bt(self):
        self.tractar_linies(self.liniesbt)

    def tractar_sub(self, arxiucsvsub):
        reader = self.open_csv_file(arxiucsvsub)
        for row in reader:
            if not row:
                continue
            sub = cnmc_inventari.Subestacion()

            identificador = row[0]
            cini = row[1]
            denominacion = row[2]
            codigo_tipo_posicion = row[3]
            codigo_ccaa = row[4]
            participacion = row[5]
            fecha_aps = row[6]
            fecha_baja = row[7]
            posiciones = row[8]

            sub.feed({
#.........这里部分代码省略.........

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import tags_context [as 别名]
class MultiprocessBased(object):

    def __init__(self, **kwargs):
        self.file_output = kwargs.pop('output', False)
        self.connection = kwargs.pop('connection')
        self.num_proc = max(1, kwargs.pop('num_proc', N_PROC))
        self.content = None
        self.input_q = multiprocessing.JoinableQueue()
        self.output_q = multiprocessing.JoinableQueue()
        self.progress_q = multiprocessing.Queue()
        self.quiet = kwargs.pop('quiet', False)
        self.interactive = kwargs.pop('interactive', False)
        self.report_name = ''
        self.base_object = ''
        if 'SENTRY_DSN' in os.environ and Client:
            self.raven = Client()
            self.raven.tags_context({'version': VERSION})
        else:
            self.raven = None
        self.content = ''


    def get_sequence(self):
        raise NotImplementedError()

    def producer(self, sequence):
        """Posem els items que serviran per fer l'informe.
        """
        for item in sequence:
            self.input_q.put(item)

    def progress(self, total):
        """Rendering del progressbar de l'informe.
        """
        widgets = ['Informe %s: ' % self.report_name,
                   Percentage(), ' ', Bar(), ' ', ETA()]
        pbar = ProgressBar(widgets=widgets, maxval=total).start()
        done = 0
        while True:
            self.progress_q.get()
            done += 1
            pbar.update(done)
            if done >= total:
                pbar.finish()

    def writer(self):
        if self.file_output:
            fio = open(self.file_output, 'wb')
        else:
            fio = StringIO()
        fitxer = csv.writer(fio, delimiter=';', lineterminator='\n')
        while True:
            try:
                item = self.output_q.get()
                if item == 'STOP':
                    break
                msg = map(lambda x: type(x)==unicode and x.encode('utf-8') or x, item)
                fitxer.writerow(msg)
            except:
                traceback.print_exc()
                if self.raven:
                    self.raven.captureException()
            finally:
                self.output_q.task_done()

        if not self.file_output:
            self.content = fio.getvalue()
        fio.close()

    def consumer(self):
        raise NotImplementedError()

    def execute(self):
        # Alias for calc
        self.calc()

    def calc(self):
        sequence = []
        sequence += self.get_sequence()
        if not self.quiet or self.interactive:
            sys.stderr.write("S'han trobat %s %s.\n" % (self.base_object, len(sequence)))
            if self.year:
                sys.stderr.write("Any %d.\n" % self.year)
            sys.stderr.flush()
        if self.interactive:
            sys.stderr.write("Correcte? ")
            raw_input()
            sys.stderr.flush()
        start = datetime.now()
        processes = [multiprocessing.Process(target=self.consumer)
                     for _ in range(0, self.num_proc)]
        if not self.quiet:
            processes += [
                multiprocessing.Process(
                    target=self.progress, args=(len(sequence),)
                )
            ]
        processes.append(multiprocessing.Process(target=self.writer))
        self.producer(sequence)
        for proc in processes:
#.........这里部分代码省略.........

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import tags_context [as 别名]
            error = parseElasticsearchError(message['error'])
            exceptions = set((error['name'],))
            indices = set()
            last = None
            for i, s in error['exceptions'].items():
                indices.add(i.split('][')[1])
                last = s[-1].keys()[0]
                for ex in s:
                    exceptions.add(ex.keys()[0])
            pprint(error)

            exception = {'values': [{'type': error['name'],
                                      'value': error['description']
                                      }]}

            raven.http_context(rq)
            raven.tags_context(dict( agent=agent,
                                    lastException=last
                                    ))
            raven.extra_context(dict(request=request,
                                     stacktrace=error['exceptions'],
                                     indices=list(indices),
                                     source=source,
                                     description=error['description']))
            print raven.capture('raven.events.Exception', time_spent=ts,
                                message="%s:%s" % (error['description'], last),
                                culprit=error['name'],
                                data=dict(exception=exception)
                                )

# 需要导入模块: from raven import Client [as 别名]
# 或者: from raven.Client import tags_context [as 别名]
from raven import Client
from irco.conf import settings
from irco import __version__


def make_excepthook(client):
    def excepthook(*exc_info):
        ident = client.get_ident(client.captureException(exc_info))
        r = sys.__excepthook__(*exc_info)
        print('-' * 80)
        print('  This exception was logged remotely. Please use the following'
              ' ID when\n  seeking support:', ident)
        print('-' * 80)
        return r
    return excepthook

enabled = settings.getboolean('logging', 'sentry')
dsn = settings.get('logging', 'sentry_dsn')

if enabled:
    sentry = Client(dsn)
    sentry.tags_context({
        'version': __version__,
    })
    if dsn:
        sys.excepthook = make_excepthook(sentry)
else:
    # Hide disabled sentry reporting
    logging.getLogger('raven.base.Client').setLevel(logging.WARNING)
    sentry = Client('')