Python SentryHandler.setFormatter方法代码示例

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [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 setFormatter [as 别名]
def server_log_handler(client):
    """ Adds sentry log handler to the logger

    :return: the sentry handler
    """
    from raven.handlers.logging import SentryHandler

    sh = SentryHandler(client=client, level=logging.ERROR)

    # Don't send Sentry events for command-line usage errors
    old_emit = sh.emit
    def emit(self, record):
        if record.message.startswith("Command-line usage error:"):
            return
        return old_emit(record)

    sh.emit = lambda x: emit(sh, x)


    fmt = ("[%(asctime)s][%(levelname)s] %(filename)s: %(lineno)d | "
            "%(message)s")
    formatter = logging.Formatter(fmt=fmt, datefmt="%H:%M:%S")
    formatter.converter = time.gmtime
    sh.setFormatter(formatter)

    logger.addHandler(sh)
    return sh

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [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 setFormatter [as 别名]
def setupLogger():
    """Set up our logger.

    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')
    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
        from raven import Client
        #pylint: enable=F0401
        myClient = Client('http://12ef42a1d4394255a2041ac0428e8ef7:'
            '[email protected]/6')
        mySentryHandler = SentryHandler(myClient)
        mySentryHandler.setFormatter(myFormatter)
        mySentryHandler.setLevel(logging.ERROR)
        addLoggingHanderOnce(myLogger, mySentryHandler)
        myLogger.debug('Sentry logging enabled')

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



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

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

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [as 别名]
def setup_logger():
    """Set up our logger with sentry support.
    """
    logger = logging.getLogger('user_map')
    logger.setLevel(logging.DEBUG)
    handler_level = logging.DEBUG
    # create formatter that will be added to the handlers
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    temp_dir = '/tmp'
    # so e.g. jenkins can override log dir.
    if 'USER_MAP_LOGFILE' in os.environ:
        file_name = os.environ['USER_MAP_LOGFILE']
    else:
        file_name = os.path.join(temp_dir, 'user-map.log')
    file_handler = logging.FileHandler(file_name)
    file_handler.setLevel(handler_level)
    # create console handler with a higher log level
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.ERROR)

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

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

    #Set formatters
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)

    # add the handlers to the logger
    add_handler_once(logger, file_handler)
    add_handler_once(logger, console_handler)

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

    patch_gevent_hub_print_exception()
    if State.config.get('sentry'):
        hdlr = SentryHandler(raven.Client(State.config['sentry'], transport=GeventedHTTPTransport))
        hdlr.setLevel(logging.ERROR)
        root.addHandler(hdlr)

    fmter = ServerLogFormatter()

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

    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 setFormatter [as 别名]
def setup_logger(sentry_url=None):
    """Run once when the module is loaded and enable logging.

    :param sentry_url: Optional url to sentry api for remote
        logging. Defaults to http://c64a83978732474ea751d432ab943a6b:
        [email protected]/5 which is the
        sentry project for InaSAFE desktop.
    :type sentry_url: str

    Borrowed heavily from this:
    http://docs.python.org/howto/logging-cookbook.html

    Use this to first initialise the logger (see safe/__init__.py)::

       from safe_qgis import utilities
       utilities.setupLogger()

    You would typically only need to do the above once ever as the
    safe model is initialised early and will set up the logger
    globally so it is available to all packages / subpackages as
    shown below.

    In a module that wants to do logging then use this example as
    a guide to get the initialised logger instance::

       # The LOGGER is initialised in utilities.py by init
       import logging
       LOGGER = logging.getLogger('InaSAFE')

    Now to log a message do::

       LOGGER.debug('Some debug message')

    .. note:: The file logs are written to the inasafe user tmp dir e.g.:
       /tmp/inasafe/23-08-2012/timlinux/logs/inasafe.log

    """
    logger = logging.getLogger('InaSAFE')
    # create formatter that will be added to the handlers
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

    qgis_handler = QgsLogHandler()
    qgis_handler.setFormatter(formatter)
    add_logging_handler_once(logger, qgis_handler)

    # Sentry handler - this is optional hence the localised import
    # It will only log if pip install raven. If raven is available
    # logging messages will be sent to http://sentry.linfiniti.com
    # We will log exceptions only there. You need to either:
    #  * Set env var 'INSAFE_SENTRY=1' present (value can be anything)
    #  * Enable the 'help improve InaSAFE by submitting errors to a remove
    #    server' option in InaSAFE options dialog
    # before this will be enabled.
    settings = QtCore.QSettings()
    flag = settings.value('inasafe/useSentry', False)
    if 'INASAFE_SENTRY' in os.environ or flag:
        if sentry_url is None:
            client = Client(
                'http://c64a83978732474ea751d432ab943a6b'
                ':[email protected]/5')
        else:
            client = Client(sentry_url)
        sentry_handler = SentryHandler(client)
        sentry_handler.setFormatter(formatter)
        sentry_handler.setLevel(logging.ERROR)
        if add_logging_handler_once(logger, sentry_handler):
            logger.debug('Sentry logging enabled in safe_qgis')
        elif 'INASAFE_SENTRY' in os.environ:
            logger.debug('Sentry logging already enabled in safe')
    else:
        logger.debug('Sentry logging disabled in safe_qgis')

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [as 别名]
def setup_logger(log_file=None, sentry_url=None):
    """Run once when the module is loaded and enable logging.

    :param log_file: Optional full path to a file to write logs to.
    :type log_file: str

    :param sentry_url: Optional url to sentry api for remote
        logging. Defaults to http://c64a83978732474ea751d432ab943a6b:
        [email protected]/5 which is the
        sentry project for InaSAFE desktop.
    :type sentry_url: str

    Borrowed heavily from this:
    http://docs.python.org/howto/logging-cookbook.html

    Use this to first initialise the logger (see safe/__init__.py)::

       from safe_qgis import utilities
       utilities.setupLogger()

    You would typically only need to do the above once ever as the
    safe model is initialised early and will set up the logger
    globally so it is available to all packages / subpackages as
    shown below.

    In a module that wants to do logging then use this example as
    a guide to get the initialised logger instance::

       # The LOGGER is initialised in utilities.py by init
       import logging
       LOGGER = logging.getLogger('InaSAFE')

    Now to log a message do::

       LOGGER.debug('Some debug message')

    .. note:: The file logs are written to the inasafe user tmp dir e.g.:
       /tmp/inasafe/23-08-2012/timlinux/logs/inasafe.log

    """
    myLogger = logging.getLogger('InaSAFE')
    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')
    # create syslog handler which logs even debug messages
    # (ariel): Make this log to /var/log/safe.log instead of
    #               /var/log/syslog
    # (Tim) Ole and I discussed this - we prefer to log into the
    # user's temporary working directory.
    myTempDir = temp_dir('logs')
    myFilename = os.path.join(myTempDir, 'inasafe.log')
    if log_file is None:
        myFileHandler = logging.FileHandler(myFilename)
    else:
        myFileHandler = logging.FileHandler(log_file)
    myFileHandler.setLevel(myDefaultHanderLevel)
    # create console handler with a higher log level
    myConsoleHandler = logging.StreamHandler()
    myConsoleHandler.setLevel(logging.INFO)

    myQGISHandler = QgsLogHandler()

    # Sentry handler - this is optional hence the localised import
    # It will only log if pip install raven. If raven is available
    # logging messages will be sent to http://sentry.linfiniti.com
    # We will log exceptions only there. You need to either:
    #  * Set env var 'INSAFE_SENTRY=1' present (value can be anything)
    #  * Enable the 'help improve InaSAFE by submitting errors to a remove
    #    server' option in InaSAFE options dialog
    # before this will be enabled.
    mySettings = QtCore.QSettings()
    myFlag = mySettings.value('inasafe/useSentry', False)
    if 'INASAFE_SENTRY' in os.environ or myFlag:
        if sentry_url is None:
            myClient = Client(
                'http://c64a83978732474ea751d432ab943a6b'
                ':[email protected]/5')
        else:
            myClient = Client(sentry_url)
        mySentryHandler = SentryHandler(myClient)
        mySentryHandler.setFormatter(myFormatter)
        mySentryHandler.setLevel(logging.ERROR)
        if add_logging_handler_once(myLogger, mySentryHandler):
            myLogger.debug('Sentry logging enabled')
    else:
        myLogger.debug('Sentry logging disabled')
    # Set formatters
    myFileHandler.setFormatter(myFormatter)
    myConsoleHandler.setFormatter(myFormatter)
    myQGISHandler.setFormatter(myFormatter)

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

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [as 别名]
def setupLogger():
    """Run once when the module is loaded and enable logging

    Args: None

    Returns: None

    Raises: None

    Borrowed heavily from this:
    http://docs.python.org/howto/logging-cookbook.html

    Use this to first initialise the logger (see safe/__init__.py)::

       from safe_qgis import utilities
       utilities.setupLogger()

    You would typically only need to do the above once ever as the
    safe modle is initialised early and will set up the logger
    globally so it is available to all packages / subpackages as
    shown below.

    In a module that wants to do logging then use this example as
    a guide to get the initialised logger instance::

       # The LOGGER is intialised in utilities.py by init
       import logging
       LOGGER = logging.getLogger('InaSAFE')

    Now to log a message do::

       LOGGER.debug('Some debug message')

    .. note:: The file logs are written to the inasafe user tmp dir e.g.:
       /tmp/inasafe/23-08-2012/timlinux/logs/inasafe.log

    """
    myLogger = logging.getLogger('InaSAFE')
    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')
    # create syslog handler which logs even debug messages
    # (ariel): Make this log to /var/log/safe.log instead of
    #               /var/log/syslog
    # (Tim) Ole and I discussed this - we prefer to log into the
    # user's temporary working directory.
    myTempDir = temp_dir('logs')
    myFilename = os.path.join(myTempDir, 'inasafe.log')
    myFileHandler = logging.FileHandler(myFilename)
    myFileHandler.setLevel(myDefaultHanderLevel)
    # create console handler with a higher log level
    myConsoleHandler = logging.StreamHandler()
    myConsoleHandler.setLevel(logging.ERROR)

    myQgisHandler = QgsLogHandler()

    # TODO: User opt in before we enable email based logging.
    # Email handler for errors
    #myEmailServer = 'localhost'
    #myEmailServerPort = 25
    #mySenderAddress = '[email protected]'
    #myRecipientAddresses = ['[email protected]']
    #mySubject = 'Error'
    #myEmailHandler = logging.handlers.SMTPHandler(
    #    (myEmailServer, myEmailServerPort),
    #                                      mySenderAddress,
    #                                      myRecipientAddresses,
    #                                      mySubject)
    #myEmailHandler.setLevel(logging.ERROR)

    # Sentry handler - this is optional hence the localised import
    # It will only log if pip install raven. If raven is available
    # logging messages will be sent to http://sentry.linfiniti.com
    # We will log exceptions only there. Only if you have the env var
    # 'INSAFE_SENTRY=1' present (value can be anything) will this be enabled.
    if 'INASAFE_SENTRY' in os.environ:
        try:
            #pylint: disable=F0401
            from raven.handlers.logging import SentryHandler
            from raven import Client
            #pylint: enable=F0401
            myClient = Client('http://5aee75e47c6740af842b3ef138d3ad33:16160af'
                              '[email protected]/'
                              '4')
            mySentryHandler = SentryHandler(myClient)
            mySentryHandler.setFormatter(myFormatter)
            mySentryHandler.setLevel(logging.ERROR)
            if addLoggingHanderOnce(myLogger, mySentryHandler):
                myLogger.debug('Sentry logging enabled')
        except ImportError:
            myLogger.debug('Sentry logging disabled')

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

#.........这里部分代码省略.........

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [as 别名]
def setup_logger(logger_name, log_file=None, sentry_url=None):
    """Run once when the module is loaded and enable logging.

    :param logger_name: The logger name that we want to set up.
    :type logger_name: str

    :param log_file: Optional full path to a file to write logs to.
    :type log_file: str

    :param sentry_url: Optional url to sentry api for remote
        logging. Defaults to http://c64a83978732474ea751d432ab943a6b:
        [email protected]/5 which is the
        sentry project for InaSAFE desktop.
    :type sentry_url: str

    Borrowed heavily from this:
    http://docs.python.org/howto/logging-cookbook.html

    Now to log a message do::

       LOGGER.debug('Some debug message')

    .. note:: The file logs are written to the inasafe user tmp dir e.g.:
       /tmp/inasafe/23-08-2012/timlinux/logs/inasafe.log

    """
    logger = logging.getLogger(logger_name)
    logger.setLevel(logging.DEBUG)
    default_handler_level = logging.DEBUG

    # create formatter that will be added to the handlers
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

    # create syslog handler which logs even debug messages
    # (ariel): Make this log to /var/log/safe.log instead of
    #               /var/log/syslog
    # (Tim) Ole and I discussed this - we prefer to log into the
    # user's temporary working directory.
    inasafe_log_path = log_file_path()
    if log_file is None:
        file_handler = logging.FileHandler(inasafe_log_path)
    else:
        file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(default_handler_level)

    # create console handler with a higher log level
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.INFO)

    # create a QGIS handler
    qgis_handler = QgsLogHandler()

    # Set formatters
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)
    qgis_handler.setFormatter(formatter)

    # add the handlers to the logger
    add_logging_handler_once(logger, file_handler)
    add_logging_handler_once(logger, console_handler)
    add_logging_handler_once(logger, qgis_handler)

    # Sentry handler - this is optional hence the localised import
    # It will only log if pip install raven. If raven is available
    # logging messages will be sent to http://sentry.linfiniti.com
    # We will log exceptions only there. You need to either:
    #  * Set env var 'INASAFE_SENTRY=1' present (value can be anything)
    # before this will be enabled or sentry is enabled in QSettings
    settings = QSettings()
    flag = settings.value('inasafe/useSentry', False, type=bool)
    env_inasafe_sentry = 'INASAFE_SENTRY' in os.environ

    if env_inasafe_sentry or flag:
        if sentry_url is None:
            client = Client(
                'http://11b7c9cb73874f97807ebc1934575e92'
                ':[email protected]/5')
        else:
            client = Client(sentry_url)
        sentry_handler = SentryHandler(client)
        sentry_handler.setFormatter(formatter)
        sentry_handler.setLevel(logging.ERROR)
        if add_logging_handler_once(logger, sentry_handler):
            logger.debug('Sentry logging enabled in safe')
    else:
        logger.debug('Sentry logging disabled in safe')

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [as 别名]
def setup_logger(sentry_url, log_file=None):
    """Run once when the module is loaded and enable logging.

    :param sentry_url: Mandatory url to sentry api for remote logging.
        Consult your sentry instance for the client instance url.
    :type sentry_url: str

    :param log_file: Optional full path to a file to write logs to.
    :type log_file: str

    Borrowed heavily from this:
    http://docs.python.org/howto/logging-cookbook.html

    Use this to first initialise the logger in your __init__.py::

       import custom_logging
       custom_logging.setup_logger('http://path to sentry')

    You would typically only need to do the above once ever as the
    safe model is initialised early and will set up the logger
    globally so it is available to all packages / subpackages as
    shown below.

    In a module that wants to do logging then use this example as
    a guide to get the initialised logger instance::

       # The LOGGER is initialised in sg_utilities.py by init
       import logging
       LOGGER = logging.getLogger('QGIS')

    Now to log a message do::

       LOGGER.debug('Some debug message')

    .. note:: The file logs are written to the user tmp dir e.g.:
       /tmp/23-08-2012/timlinux/logs/qgis.log

    """
    logger = logging.getLogger('QGIS')
    logger.setLevel(logging.DEBUG)
    default_handler_level = logging.DEBUG
    # create formatter that will be added to the handlers
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    # create syslog handler which logs even debug messages
    log_temp_dir = temp_dir('logs')
    path = log_file_path()
    if log_file is None:
        file_handler = logging.FileHandler(path)
    else:
        file_handler = logging.FileHandler(log_file)
    file_handler.setLevel(default_handler_level)
    # create console handler with a higher log level
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.INFO)

    qgis_handler = QgsLogHandler()

    # Sentry handler - this is optional hence the localised import
    # It will only log if pip install raven. If raven is available
    # logging messages will be sent to the sentry host.
    # We will only log exceptions. You need to either:
    #  * Set env var 'SENTRY' present (value can be anything)
    #  * Enable the 'plugins/use_sentry' QSettings option
    # before this will be enabled.
    client = Client(sentry_url)
    sentry_handler = SentryHandler(client)
    sentry_handler.setFormatter(formatter)
    sentry_handler.setLevel(logging.ERROR)
    if add_logging_handler_once(logger, sentry_handler):
        logger.debug('Sentry logging enabled')
    # Set formatters
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)
    qgis_handler.setFormatter(formatter)

    # add the handlers to the logger
    add_logging_handler_once(logger, file_handler)
    add_logging_handler_once(logger, console_handler)
    add_logging_handler_once(logger, qgis_handler)

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [as 别名]
def main(options) :
    """Prepare the main loop and run it. 

    Mostly consists of a bunch of high-level preparatory calls, protected
    by try blocks in the case of an exception."""

    config_dict = getConfiguration("/etc/nimbus/nimbus.conf")

    logger = logging.getLogger()
    logger.setLevel(logging.INFO)

    formatter = Formatter('%(asctime)s %(levelname)-8s %(message)s')

    fileHandler = FileHandler('/var/log/nimbus.log')
    fileHandler.setFormatter(formatter)

    logger.addHandler(fileHandler)

    if 'sentry_key' in config_dict:
        sentryClient = Client('https://%[email protected]/63812' % config_dict['sentry_key'])
        sentryHandler = SentryHandler(sentryClient)
        sentryHandler.setFormatter(formatter)
        setup_logging(sentryHandler)

    logging.getLogger("requests").setLevel(logging.WARNING)
    logging.getLogger("urllib3").setLevel(logging.WARNING)

    signal.signal(signal.SIGHUP, sigHUPhandler)
    signal.signal(signal.SIGTERM, sigTERMhandler)

    logging.info("engine: Initializing nimbus")
    logging.info("engine: Using Python %s" % sys.version)
    logging.info("engine: Platform %s" % platform.platform())

    cwd = os.getcwd()

    if int(config_dict.get('debug', 0)):
        logger.setLevel(logging.DEBUG)
        logging.debug("Logging set to DEBUG")

    while True:

        os.chdir(cwd)

        try:
            if time.time() < 946684800:
                logging.critical("engine: Time skew is unacceptable.")
                raise InitializationError

            logging.info("engine: Initializing engine")

            engine = Engine(config_dict)
    
            logging.info("engine: Starting up nimbus")

            engine.run()

            logging.error("engine: Unexpected exit from main loop. Program exiting.")
    
        except InitializationError, e:
            logging.error("engine: Unable to load driver: %s" % e)
            if options.loop_on_init:
                logging.info("    ****  Waiting 60 seconds then retrying...")
                time.sleep(60)
                logging.info("engine: retrying...")
            else:
                logging.info("    ****  Exiting...")
                sys.exit(nimbus.IO_ERROR)

        except nimbusdrivers.WeeWxIOError, e:
            logging.critical("engine: Caught WeeWxIOError: %s" % e)
            logging.critical("    ****  Waiting 60 seconds then retrying...")
            time.sleep(60)
            logging.info("engine: retrying...")

# 需要导入模块: from raven.handlers.logging import SentryHandler [as 别名]
# 或者: from raven.handlers.logging.SentryHandler import setFormatter [as 别名]
def setupLogger(theLogFile=None, theSentryUrl=None):
    """Run once when the module is loaded and enable logging

    Args:
        * theLogFile: str - optional full path to a file to write logs to.
        * theSentryUrl: str - optional url to sentry api for remote logging.
            Defaults to http://c64a83978732474ea751d432ab943a6b
                :[email protected]/5
            which is the sentry project for InaSAFE desktop.

    Returns: None

    Raises: None

    Borrowed heavily from this:
    http://docs.python.org/howto/logging-cookbook.html

    Use this to first initialise the logger (see safe/__init__.py)::

       from safe_qgis import utilities
       utilities.setupLogger()

    You would typically only need to do the above once ever as the
    safe modle is initialised early and will set up the logger
    globally so it is available to all packages / subpackages as
    shown below.

    In a module that wants to do logging then use this example as
    a guide to get the initialised logger instance::

       # The LOGGER is intialised in utilities.py by init
       import logging
       LOGGER = logging.getLogger('InaSAFE')

    Now to log a message do::

       LOGGER.debug('Some debug message')

    .. note:: The file logs are written to the inasafe user tmp dir e.g.:
       /tmp/inasafe/23-08-2012/timlinux/logs/inasafe.log

    """
    myLogger = logging.getLogger("InaSAFE")
    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")
    # create syslog handler which logs even debug messages
    # (ariel): Make this log to /var/log/safe.log instead of
    #               /var/log/syslog
    # (Tim) Ole and I discussed this - we prefer to log into the
    # user's temporary working directory.
    myTempDir = temp_dir("logs")
    myFilename = os.path.join(myTempDir, "inasafe.log")
    if theLogFile is None:
        myFileHandler = logging.FileHandler(myFilename)
    else:
        myFileHandler = logging.FileHandler(theLogFile)
    myFileHandler.setLevel(myDefaultHanderLevel)
    # create console handler with a higher log level
    myConsoleHandler = logging.StreamHandler()
    myConsoleHandler.setLevel(logging.INFO)

    myQGISHandler = QgsLogHandler()

    # TODO: User opt in before we enable email based logging.
    # Email handler for errors
    # myEmailServer = 'localhost'
    # myEmailServerPort = 25
    # mySenderAddress = '[email protected]'
    # myRecipientAddresses = ['[email protected]']
    # mySubject = 'Error'
    # myEmailHandler = logging.handlers.SMTPHandler(
    #    (myEmailServer, myEmailServerPort),
    #                                      mySenderAddress,
    #                                      myRecipientAddresses,
    #                                      mySubject)
    # myEmailHandler.setLevel(logging.ERROR)

    # Sentry handler - this is optional hence the localised import
    # It will only log if pip install raven. If raven is available
    # logging messages will be sent to http://sentry.linfiniti.com
    # We will log exceptions only there. You need to either:
    #  * Set env var 'INSAFE_SENTRY=1' present (value can be anything)
    #  * Enable the 'help improve InaSAFE by submitting errors to a remove
    #    server' option in InaSAFE options dialog
    # before this will be enabled.
    mySettings = QtCore.QSettings()
    myFlag = mySettings.value("inasafe/useSentry", False).toBool()
    if "INASAFE_SENTRY" in os.environ or myFlag:
        if theSentryUrl is None:
            myClient = Client(
                "http://c64a83978732474ea751d432ab943a6b" ":[email protected]/5"
            )
        else:
            myClient = Client(theSentryUrl)
        mySentryHandler = SentryHandler(myClient)
        mySentryHandler.setFormatter(myFormatter)
        mySentryHandler.setLevel(logging.ERROR)
        if addLoggingHanderOnce(myLogger, mySentryHandler):
#.........这里部分代码省略.........