Python SentryHandler.setLevel方法代码示例

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
 def set_logger(cls, filename, to_sentry=False):
     logger = logging.getLogger()
     logger.setLevel(getattr(logging, config['logging']['level'].upper()))
     logger.handlers = []
     format_ = logging.Formatter(
         '[%(levelname)s %(asctime)s.%(msecs)d %(module)s:%(lineno)d]: %(message)s', 
         datefmt='%Y-%m-%d %H:%M:%S'
     )
     if config['logging']['path']:
         channel = logging.handlers.RotatingFileHandler(
             filename=os.path.join(config['logging']['path'], filename),
             maxBytes=config['logging']['max_size'],
             backupCount=config['logging']['num_backups']
         )
         channel.setFormatter(format_)
         logger.addHandler(channel)
     else:# send to console instead of file
         channel = logging.StreamHandler()
         channel.setFormatter(format_)
         logger.addHandler(channel)
     if to_sentry and config['sentry_dsn']:
         handler = SentryHandler(
             config['sentry_dsn']
         )
         handler.setLevel('ERROR')
         logger.addHandler(handler)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def init(level, sentry_dsn, colored=False):
    root = logging.getLogger()
    root.setLevel(0)

    hdlr = logging.FileHandler('client_log.txt', encoding='utf-8')
    hdlr.setLevel(logging.INFO)
    root.addHandler(hdlr)

    hdlr = SentryHandler(raven.Client(sentry_dsn, transport=GeventedHTTPTransport))
    hdlr.setLevel(logging.ERROR)
    root.addHandler(hdlr)

    hdlr = logging.StreamHandler(sys.stdout)
    hdlr.setLevel(getattr(logging, level))

    if colored:
        from colorlog import ColoredFormatter

        formatter = ColoredFormatter(
            "%(log_color)s%(message)s%(reset)s",
            log_colors={
                'CRITICAL': 'bold_red',
                'ERROR': 'red',
                'WARNING': 'yellow',
                'INFO': 'green',
                'DEBUG': 'blue',
            }
        )
        hdlr.setFormatter(formatter)

    root.addHandler(hdlr)

    root.info(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
    root.info('==============================================')

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
    def on_inst_register_clicked(self, *args, **kwargs):
        '''send the registration data as sentry info log message
        '''

        # create the handler first
        from raven import Client
        from raven.handlers.logging import SentryHandler
        sentry_client = Client('https://59105d22a4ad49158796088c26bf8e4c:'
                               '[email protected]'
                               'app.getsentry.com/45704')
        handler = SentryHandler(sentry_client)
        handler.setLevel(logging.INFO)

        # the registration logger gets the above handler
        registrations = logging.getLogger('bauble.registrations')
        registrations.setLevel(logging.INFO)
        registrations.addHandler(handler)

        # produce the log record
        registrations.info([(key, getattr(self.model, key))
                            for key in self.widget_to_field_map.values()])

        # remove the handler after usage
        registrations.removeHandler(handler)

        # disable button, so user will not send registration twice
        self.view.widget_set_sensitive('inst_register', False)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
 def sentry_logger(sender, logger, loglevel, logfile, format,
                   colorize, **kw):
     filter_ = CeleryFilter()
     handler = SentryHandler(client)
     handler.setLevel(loglevel)
     handler.addFilter(filter_)
     logger.addHandler(handler)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
    def start(self):
        # remove all handlers
        self.handlers = []

        # sentry log handler
        sentry_client = raven.Client('https://3d25da5bd0b34990b282e7112a6113ab:d585806dc45540a891dda0c3418fb8d5'
                                     '@sentry.sickrage.ca/4?verify_ssl=0', release=sickrage.version(),
                                     repos={'sickrage': {'name': 'sickrage/sickrage'}})

        sentry_handler = SentryHandler(client=sentry_client, tags={'platform': platform.platform()})
        sentry_handler.setLevel(self.logLevels['ERROR'])
        sentry_handler.set_name('sentry')
        self.addHandler(sentry_handler)

        # console log handler
        if self.consoleLogging:
            console_handler = logging.StreamHandler()
            formatter = logging.Formatter('%(asctime)s %(levelname)s::%(threadName)s::%(message)s', '%H:%M:%S')

            console_handler.setFormatter(formatter)
            console_handler.setLevel(self.logLevels['INFO'] if not self.debugLogging else self.logLevels['DEBUG'])
            self.addHandler(console_handler)

        # file log handlers
        if self.logFile:
            # make logs folder if it doesn't exist
            if not os.path.exists(os.path.dirname(self.logFile)):
                if not makeDir(os.path.dirname(self.logFile)):
                    return

            if sickrage.app.developer:
                rfh = FileHandler(
                    filename=self.logFile,
                )
            else:
                rfh = RotatingFileHandler(
                    filename=self.logFile,
                    maxBytes=self.logSize,
                    backupCount=self.logNr
                )

            rfh_errors = RotatingFileHandler(
                filename=self.logFile.replace('.log', '.error.log'),
                maxBytes=self.logSize,
                backupCount=self.logNr
            )

            formatter = logging.Formatter('%(asctime)s %(levelname)s::%(threadName)s::%(message)s', '%Y-%m-%d %H:%M:%S')

            rfh.setFormatter(formatter)
            rfh.setLevel(self.logLevels['INFO'] if not self.debugLogging else self.logLevels['DEBUG'])
            self.addHandler(rfh)

            rfh_errors.setFormatter(formatter)
            rfh_errors.setLevel(self.logLevels['ERROR'])
            self.addHandler(rfh_errors)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
    def process_logger_event(sender, logger, loglevel, logfile, format, colorize, **kw):
        import logging

        logger = logging.getLogger()
        handler = SentryHandler(client)
        if handler.__class__ in list(map(type, logger.handlers)):
            return False
        handler.setLevel(logging.ERROR)
        handler.addFilter(CeleryFilter())
        logger.addHandler(handler)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def create_app(load_admin=True):
    from redash import extensions, handlers
    from redash.handlers.webpack import configure_webpack
    from redash.handlers import chrome_logger
    from redash.admin import init_admin
    from redash.models import db
    from redash.authentication import setup_authentication
    from redash.metrics.request import provision_app

    app = Flask(__name__,
                template_folder=settings.STATIC_ASSETS_PATH,
                static_folder=settings.STATIC_ASSETS_PATH,
                static_path='/static')

    # Make sure we get the right referral address even behind proxies like nginx.
    app.wsgi_app = ProxyFix(app.wsgi_app, settings.PROXIES_COUNT)
    #app.wsgi_app = ReverseProxied(app.wsgi_app)
    app.url_map.converters['org_slug'] = SlugConverter


    if settings.ENFORCE_HTTPS:
        SSLify(app, skips=['ping'])

    if settings.SENTRY_DSN:
        from raven import Client
        from raven.contrib.flask import Sentry
        from raven.handlers.logging import SentryHandler

        client = Client(settings.SENTRY_DSN, release=__version__, install_logging_hook=False)
        sentry = Sentry(app, client=client)
        sentry.client.release = __version__

        sentry_handler = SentryHandler(client=client)
        sentry_handler.setLevel(logging.ERROR)
        logging.getLogger().addHandler(sentry_handler)

    # configure our database
    app.config['SQLALCHEMY_DATABASE_URI'] = settings.SQLALCHEMY_DATABASE_URI
    app.config.update(settings.all_settings())

    provision_app(app)
    db.init_app(app)
    migrate.init_app(app, db)
    if load_admin:
        init_admin(app)
    mail.init_app(app)
    setup_authentication(app)
    limiter.init_app(app)
    handlers.init_app(app)
    configure_webpack(app)
    extensions.init_extensions(app)
    chrome_logger.init_app(app)

    return app

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def add_sentry_handler_to_celery_task_logger(client, sentry_handler_log_level):
    handler = SentryHandler(client)
    handler.setLevel(sentry_handler_log_level)

    def process_task_logger_event(sender, logger, loglevel, logfile, format,
                             colorize, **kw):
        for h in logger.handlers:
            if type(h) == SentryHandler:
                return False
        logger.addHandler(handler)

    after_setup_task_logger.connect(process_task_logger_event, weak=False)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def setup_raven():
    '''we setup sentry to get all stuff from our logs'''
    pcfg = AppBuilder.get_pcfg()
    from raven.handlers.logging import SentryHandler
    from raven import Client
    from raven.conf import setup_logging
    client = Client(pcfg['raven_dsn'])
    handler = SentryHandler(client)
    # TODO VERIFY THIS -> This is the way to do it if you have a paid account, each log call is an event so this isn't going to work for free accounts...
    handler.setLevel(pcfg["raven_loglevel"])
    setup_logging(handler)
    return client

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def setup_logger():
    """Set up our logger with sentry support.

    Args: None

    Returns: None

    Raises: None
    """
    myLogger = logging.getLogger('osm-reporter')
    myLogger.setLevel(logging.DEBUG)
    myDefaultHanderLevel = logging.DEBUG
    # create formatter that will be added to the handlers
    myFormatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    myTempDir = '/tmp'
    # so e.g. jenkins can override log dir.
    if 'OSM_REPORTER_LOGFILE' in os.environ:
        myFilename = os.environ['OSM_REPORTER_LOGFILE']
    else:
        myFilename = os.path.join(myTempDir, 'reporter.log')
    myFileHandler = logging.FileHandler(myFilename)
    myFileHandler.setLevel(myDefaultHanderLevel)
    # create console handler with a higher log level
    myConsoleHandler = logging.StreamHandler()
    myConsoleHandler.setLevel(logging.ERROR)

    try:
        #pylint: disable=F0401
        from raven.handlers.logging import SentryHandler
        # noinspection PyUnresolvedReferences
        from raven import Client
        #pylint: enable=F0401
        myClient = Client(
            'http://12ef42a1d4394255a2041ac0428e8ef7:'
            '[email protected]/6')
        mySentryHandler = SentryHandler(myClient)
        mySentryHandler.setFormatter(myFormatter)
        mySentryHandler.setLevel(logging.ERROR)
        add_handler_once(myLogger, mySentryHandler)
        myLogger.debug('Sentry logging enabled')

    except ImportError:
        myLogger.debug('Sentry logging disabled. Try pip install raven')

    #Set formatters
    myFileHandler.setFormatter(myFormatter)
    myConsoleHandler.setFormatter(myFormatter)

    # add the handlers to the logger
    add_handler_once(myLogger, myFileHandler)
    add_handler_once(myLogger, myConsoleHandler)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def init_raven_client(dsn):
    global _sentry
    _sentry = raven.Client(
        dsn=dsn,
        transport=raven.transport.threaded_requests.ThreadedRequestsHTTPTransport,
        ignore_exceptions={'KeyboardInterrupt'},
        logging=True,
    )
    sentry_errors_logger = logging.getLogger("sentry.errors")
    sentry_errors_logger.addHandler(logging.StreamHandler())
    handler = SentryHandler(_sentry)
    handler.setLevel(logging.ERROR)
    setup_logging(handler)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def init_unity(level, sentry_dsn):
    root = logging.getLogger()
    root.setLevel(0)

    hdlr = SentryHandler(raven.Client(sentry_dsn, transport=GeventedHTTPTransport))
    hdlr.setLevel(logging.ERROR)
    root.addHandler(hdlr)

    hdlr = UnityLogHandler()
    hdlr.setLevel(getattr(logging, level))
    root.addHandler(hdlr)

    root.info(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
    root.info('==============================================')

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def setup(dsn, level, propagate_sentry_errors=False):
    client = make_client(dsn, False)
    
    from raven.handlers.logging import SentryHandler
    global handler
    handler = SentryHandler(client)
    handler.setLevel(level)
    handler.dsn = dsn
    
    from raven.conf import setup_logging
    kwargs = {}
    if propagate_sentry_errors:
        kwargs["exclude"] = []
    setup_logging(handler, **kwargs)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
    def check_args(self, args):
        # check allow_other and allow_root
        if args.allow_other:
            args.allow_root = False
        else:
            args.allow_root = True

        # check log_level
        if args.debug:
            args.log_level = 'debug'

        # setup logging
        if args.log != "syslog":
            if args.log in ('-', '/dev/stdout'):
                handler = StreamHandler(sys.stdout)
            else:
                handler = TimedRotatingFileHandler(args.log, when="midnight")
            handler.setFormatter(Formatter(fmt='%(asctime)s %(threadName)s: '
                                           '%(message)s',
                                           datefmt='%B-%d-%Y %H:%M:%S'))
        else:
            if sys.platform == 'darwin':
                handler = SysLogHandler(address="/var/run/syslog")
            else:
                handler = SysLogHandler(address="/dev/log")
            logger_fmt = 'GitFS on {mount_point} [%(process)d]: %(threadName)s: '\
                         '%(message)s'.format(mount_point=args.mount_point)
            handler.setFormatter(Formatter(fmt=logger_fmt))

        if args.sentry_dsn != '':
            from raven.conf import setup_logging
            from raven.handlers.logging import SentryHandler

            sentry_handler = SentryHandler(args.sentry_dsn)
            sentry_handler.setLevel("ERROR")
            setup_logging(sentry_handler)
            log.addHandler(sentry_handler)

        handler.setLevel(args.log_level.upper())
        log.setLevel(args.log_level.upper())
        log.addHandler(handler)

        # set cache size
        lru_cache.maxsize = args.cache_size

        # return absolute repository's path
        args.repo_path = os.path.abspath(args.repo_path)

        return args

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setLevel [as 别名]
def setup_logging():
    logger = app.logger
    file_handler = logging.FileHandler(CONF.get("logging", "file"))
    file_handler.setFormatter(logging.Formatter(
        '%(asctime)s %(levelname)s %(message)s'))
    log_level = getattr(logging, CONF.get("logging", "level"))
    logger.setLevel(log_level)
    logger.addHandler(file_handler)
    raven_dsn = CONF.get("logging", "sentry")

    if raven_dsn:
        raven_log_level = getattr(logging, CONF.get("logging", "sentry_level"))
        sentry_handler = SentryHandler(raven_dsn)
        sentry_handler.setLevel(raven_log_level)
        logger.addHandler(sentry_handler)