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('==============================================')
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
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 not record.message.startswith("Command-line usage error:"): 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
def logger_init(self): """ Initialize the logger globally. :returns: True """ # Let's attempt to make the log directory if it doesn't exist os.makedirs(self.log_dir, exist_ok=True) # Instantiate a logger self.log = logging.getLogger("stoq") # Set the default logging level self.log.setLevel(self.log_level.upper()) # Define the log filename and path log_file = "stoq.log" self.log_path = os.path.abspath(os.path.join(self.log_dir, log_file)) # Setup our logfile file_handler = logging.handlers.RotatingFileHandler(filename=self.log_path, mode='a', maxBytes=int(self.log_maxbytes), backupCount=int(self.log_backup_count)) # Setup our STDERR output stderr_handler = logging.StreamHandler() if self.log_syntax == "json": formatter = jsonlogger.JsonFormatter else: formatter = logging.Formatter # Define the format of the log file log_format = formatter("%(asctime)s %(levelname)s %(name)s:%(filename)s:%(funcName)s:%(lineno)s: " "%(message)s", datefmt='%Y-%m-%d %H:%M:%S') stderr_logformat = formatter("[%(asctime)s %(levelname)s] %(name)s: %(message)s") file_handler.setFormatter(log_format) stderr_handler.setFormatter(stderr_logformat) # Attach the handler to the logger self.log.addHandler(file_handler) self.log.addHandler(stderr_handler) # If logging to sentry.io, setup the logger if raven_imported and self.sentry_url: try: sentry_handler = SentryHandler(self.sentry_url, ignore_exceptions=self.sentry_ignore_list) sentry_handler.setFormatter("[%(asctime)s][%(levelname)s] %(name)s " "%(filename)s:%(funcName)s:%(lineno)d | %(message)s") sentry_handler.setLevel(logging.WARN) self.log.addHandler(sentry_handler) except: self.log.error("Unable to initiate logging to Sentry")
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://*****:*****@sentry.linfiniti.com/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)
def initialize_sentry_logging(sentry_credentials, logging_level, logging_root=''): the_logger = logging.getLogger(logging_root) client = Client( 'http://{s.username}:{s.password}@{s.url}/{s.project}'.format( s=sentry_credentials)) sentry_handler = SentryHandler(client) sentry_handler.setLevel(logging_level) sentry_handler.setFormatter(logging.Formatter(LOG_FORMAT)) sentry_handler.set_name('SentryHandler') remove_handler_if_existing(sentry_handler, logging_root) the_logger.handlers.append(sentry_handler)
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://*****:*****@sentry.linfiniti.com/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)
def setup_logger(): """Set up our logger with sentry support. """ logger = logging.getLogger('osm-reporter') 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') temp_dir = '/tmp' # so e.g. jenkins can override log dir. if 'OSM_REPORTER_LOGFILE' in os.environ: file_name = os.environ['OSM_REPORTER_LOGFILE'] else: file_name = os.path.join(temp_dir, 'reporter.log') file_handler = logging.FileHandler(file_name) file_handler.setLevel(default_handler_level) # create console handler with a higher log level console_handler = logging.StreamHandler() console_handler.setLevel(logging.DEBUG) try: # pylint: disable=F0401 # noinspection PyUnresolvedReferences from raven.handlers.logging import SentryHandler # noinspection PyUnresolvedReferences from raven import Client # pylint: enable=F0401 client = Client( 'http://*****:*****@sentry.linfiniti.com/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)
def setup_logger(): """Set up our logger with sentry support. """ logger = logging.getLogger('osm-reporter') 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') temp_dir = '/tmp' # so e.g. jenkins can override log dir. if 'OSM_REPORTER_LOGFILE' in os.environ: file_name = os.environ['OSM_REPORTER_LOGFILE'] else: file_name = os.path.join(temp_dir, 'reporter.log') file_handler = logging.FileHandler(file_name) file_handler.setLevel(default_handler_level) # create console handler with a higher log level console_handler = logging.StreamHandler() console_handler.setLevel(logging.DEBUG) try: # pylint: disable=F0401 # noinspection PyUnresolvedReferences from raven.handlers.logging import SentryHandler # noinspection PyUnresolvedReferences from raven import Client # pylint: enable=F0401 client = Client( 'http://*****:*****@sentry.kartoza.com/25') 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)
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://*****:*****@sentry.linfiniti.com/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)
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('==============================================')
def init(level, sentry_dsn, release, colored=False): patch_gevent_hub_print_exception() root = logging.getLogger() root.setLevel(0) hdlr = logging.FileHandler('client_log.txt', encoding='utf-8') hdlr.setLevel(logging.INFO) root.addHandler(hdlr) if sentry_dsn: hdlr = SentryHandler( raven.Client(sentry_dsn, transport=GeventedHTTPTransport, release=release)) hdlr.setLevel(logging.ERROR) root.addHandler(hdlr) hdlr = logging.StreamHandler(sys.stdout) hdlr.setLevel(getattr(logging, level)) logging.getLogger('sentry.errors').setLevel(1000) 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('==============================================')
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)
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')
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')
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)
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 = '*****@*****.**' #myRecipientAddresses = ['*****@*****.**'] #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://*****:*****@sentry.linfiniti.com/' '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) # add the handlers to the logger addLoggingHanderOnce(myLogger, myFileHandler) addLoggingHanderOnce(myLogger, myConsoleHandler) #addLoggingHanderOnce(myLogger, myEmailHandler) addLoggingHanderOnce(myLogger, myQgisHandler)
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 = '*****@*****.**' # myRecipientAddresses = ['*****@*****.**'] # 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): myLogger.debug("Sentry logging enabled") else: myLogger.debug("Sentry logging disabled") # Set formatters myFileHandler.setFormatter(myFormatter) myConsoleHandler.setFormatter(myFormatter) # myEmailHandler.setFormatter(myFormatter) myQGISHandler.setFormatter(myFormatter) # add the handlers to the logger addLoggingHanderOnce(myLogger, myFileHandler) addLoggingHanderOnce(myLogger, myConsoleHandler) # addLoggingHanderOnce(myLogger, myEmailHandler) addLoggingHanderOnce(myLogger, myQGISHandler)
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')
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)
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 URL defined in safe.definitions.sentry.py 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) logging_level = int(os.environ.get('INASAFE_LOGGING_LEVEL', logging.DEBUG)) logger.setLevel(logging_level) default_handler_level = logging_level # 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) file_handler.setFormatter(formatter) add_logging_handler_once(logger, file_handler) if 'MUTE_LOGS' not in os.environ: # create console handler with a higher log level console_handler = logging.StreamHandler() console_handler.setLevel(logging.INFO) console_handler.setFormatter(formatter) add_logging_handler_once(logger, console_handler) # create a QGIS handler qgis_handler = QgsLogHandler() qgis_handler.setFormatter(formatter) add_logging_handler_once(logger, qgis_handler) # Sentry handler - this is optional hence the localised import # If raven is available logging messages will be sent to # http://sentry.kartoza.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 qsettings_flag = QSettings().value('inasafe/useSentry', False, type=bool) environment_flag = 'INASAFE_SENTRY' in os.environ if environment_flag or qsettings_flag: if sentry_url is None: sentry_url = PRODUCTION_SERVER tags = dict() tags[provenance_gdal_version['provenance_key']] = gdal.__version__ tags[provenance_os['provenance_key']] = readable_os_version() qgis_short_version = provenance_qgis_version['provenance_key'] qgis_full_version = qgis_short_version + '_full' versions = [str(v) for v in qgis_version_detailed()] tags[qgis_short_version] = '.'.join(versions[0:2]) tags[qgis_full_version] = '.'.join(versions[0:3]) tags[provenance_qt_version['provenance_key']] = QT_VERSION_STR hostname = os.environ.get('HOSTNAME_SENTRY', socket.gethostname()) sentry_handler = SentryHandler( dsn=sentry_url, name=hostname, release=get_version(), tags=tags, ) 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')
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...")
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')
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 = '*****@*****.**' #myRecipientAddresses = ['*****@*****.**'] #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://*****:*****@sentry.linfiniti.com/' '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) # add the handlers to the logger addLoggingHanderOnce(myLogger, myFileHandler) addLoggingHanderOnce(myLogger, myConsoleHandler) #addLoggingHanderOnce(myLogger, myEmailHandler) addLoggingHanderOnce(myLogger, myQgisHandler)
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)