本文整理汇总了Python中raven.handlers.logging.SentryHandler.setFormatter方法的典型用法代码示例。如果您正苦于以下问题:Python SentryHandler.setFormatter方法的具体用法?Python SentryHandler.setFormatter怎么用?Python SentryHandler.setFormatter使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类raven.handlers.logging.SentryHandler
的用法示例。
在下文中一共展示了SentryHandler.setFormatter方法的13个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: init
# 需要导入模块: 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('==============================================')
示例2: server_log_handler
# 需要导入模块: 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
示例3: setup_logger
# 需要导入模块: 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)
示例4: setupLogger
# 需要导入模块: 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)
示例5: setup_logger
# 需要导入模块: 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)
示例6: init_logging
# 需要导入模块: 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('==============================================')
示例7: setup_logger
# 需要导入模块: 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')
示例8: setup_logger
# 需要导入模块: 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)
示例9: setupLogger
# 需要导入模块: 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)
#.........这里部分代码省略.........
示例10: setup_logger
# 需要导入模块: 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')
示例11: setup_logger
# 需要导入模块: 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)
示例12: main
# 需要导入模块: 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...")
示例13: setupLogger
# 需要导入模块: 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):
#.........这里部分代码省略.........