Python logging.Logger() Examples

The following are code examples for showing how to use logging.Logger(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don't like. You can also save this page to your account.

Example 1
Project: otRebuilder   Author: Pal3love   File: py23.py    (MIT License) View Source Project 6 votes vote down vote up
def callHandlers(self, record):
		# this is the same as Python 3.5's logging.Logger.callHandlers
		c = self
		found = 0
		while c:
			for hdlr in c.handlers:
				found = found + 1
				if record.levelno >= hdlr.level:
					hdlr.handle(record)
			if not c.propagate:
				c = None  # break out
			else:
				c = c.parent
		if (found == 0):
			if logging.lastResort:
				if record.levelno >= logging.lastResort.level:
					logging.lastResort.handle(record)
			elif logging.raiseExceptions and not self.manager.emittedNoHandlerWarning:
				sys.stderr.write("No handlers could be found for logger"
								 " \"%s\"\n" % self.name)
				self.manager.emittedNoHandlerWarning = True 
Example 2
Project: virtualbmc   Author: umago   File: log.py    (Apache License 2.0) View Source Project 6 votes vote down vote up
def __init__(self, debug=False, logfile=None):
        logging.Logger.__init__(self, 'VirtualBMC')
        try:
            if logfile is not None:
                self.handler = logging.FileHandler(logfile)
            else:
                self.handler = logging.StreamHandler()

            formatter = logging.Formatter(DEFAULT_LOG_FORMAT)
            self.handler.setFormatter(formatter)
            self.addHandler(self.handler)

            if debug:
                self.setLevel(logging.DEBUG)
            else:
                self.setLevel(logging.INFO)

        except IOError, e:
            if e.errno == errno.EACCES:
                pass 
Example 3
Project: StratoBalloon   Author: delattreb   File: com_logger.py    (GNU General Public License v3.0) View Source Project 6 votes vote down vote up
def __init__(self, name = ''):
        conf = com_config.Config()
        self.config = conf.getconfig()
        
        self.logger = logging.Logger(name, logging.DEBUG)
        self.logger.name = name
        
        # Formatter
        formatterfile = logging.Formatter('%(asctime)s %(levelname)s : %(name)s - %(message)s', datefmt='%d/%m/%Y %H:%M:%S')
        formatterconsole = colorlog.ColoredFormatter('%(asctime)s %(log_color)s%(levelname)s : %(name)s - %(message)s', datefmt='%d/%m/%Y %H:%M:%S',
                                                     log_colors={'DEBUG':    'white', 'INFO': 'green',
                                                                 'WARNING':  'bold_yellow', 'ERROR': 'bold_red',
                                                                 'CRITICAL': 'bold_red'})
        
        # First logger (file)
        self.logger.setLevel(logging.DEBUG)
        file_handler = RotatingFileHandler(self.config['LOGGER']['logfile'], 'a', int(self.config['LOGGER']['logfilesize']), 1)
        file_handler.setLevel(int(self.config['LOGGER']['levelfile']))
        file_handler.setFormatter(formatterfile)
        self.logger.addHandler(file_handler)
        
        # second logger (console)
        steam_handler = logging.StreamHandler()
        steam_handler.setLevel(int(self.config['LOGGER']['levelconsole']))
        steam_handler.setFormatter(formatterconsole)
        self.logger.addHandler(steam_handler) 
Example 4
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: log_test.py    (MIT License) View Source Project 6 votes vote down vote up
def setUp(self):
        self.formatter = LogFormatter(color=False)
        # Fake color support.  We can't guarantee anything about the $TERM
        # variable when the tests are run, so just patch in some values
        # for testing.  (testing with color off fails to expose some potential
        # encoding issues from the control characters)
        self.formatter._colors = {
            logging.ERROR: u("\u0001"),
        }
        self.formatter._normal = u("\u0002")
        # construct a Logger directly to bypass getLogger's caching
        self.logger = logging.Logger('LogFormatterTest')
        self.logger.propagate = False
        self.tempdir = tempfile.mkdtemp()
        self.filename = os.path.join(self.tempdir, 'log.out')
        self.handler = self.make_handler(self.filename)
        self.handler.setFormatter(self.formatter)
        self.logger.addHandler(self.handler) 
Example 5
Project: aio-service-client   Author: alfred82santa   File: factories.py    (GNU Lesser General Public License v3.0) View Source Project 6 votes vote down vote up
def __call__(self, spec=None, spec_loader=None, plugins=None,
                 parser=None, serializer=None, logger=None, **kwargs):
        if spec_loader:
            spec = load_spec_by_spec_loader(spec_loader, self.loader)

        try:
            plugins = self.iter_loaded_item_list(plugins, BasePlugin)
        except TypeError:  # pragma: no cover
            pass

        if isinstance(parser, str):
            parser = self.loader.load_class(parser)

        if isinstance(serializer, str):
            serializer = self.loader.load_class(serializer)

        try:
            logger = self.load_item(logger, Logger)
        except TypeError:  # pragma: no cover
            pass

        return super(ServiceClientFactory, self).__call__(spec=spec, plugins=plugins, parser=parser,
                                                          serializer=serializer, logger=logger, **kwargs) 
Example 6
Project: user-sync.py   Author: adobe-apiplatform   File: directory_okta_test.py    (license) View Source Project 6 votes vote down vote up
def setUp(self):
        class MockResponse:
            def __init__(self, status_code, data):
                self.status_code = status_code
                self.text = json.dumps(data)

        self.mock_response = MockResponse

        self.orig_directory_init = OktaDirectoryConnector.__init__

        OktaDirectoryConnector.__init__ = mock.Mock(return_value=None)
        directory = OktaDirectoryConnector({})
        directory.options = {'all_users_filter': None, 'group_filter_format': '{group}'}
        directory.logger = mock.create_autospec(logging.Logger)
        directory.groups_client = okta.UserGroupsClient('example.com', 'xyz')

        self.directory = directory 
Example 7
Project: user-sync.py   Author: adobe-apiplatform   File: directory_okta_test.py    (license) View Source Project 6 votes vote down vote up
def setUp(self):
        class MockResponse:
            def __init__(self, status_code, data):
                self.status_code = status_code
                self.text = json.dumps(data)

        self.mock_response = MockResponse

        self.orig_directory_init = OktaDirectoryConnector.__init__

        OktaDirectoryConnector.__init__ = mock.Mock(return_value=None)
        directory = OktaDirectoryConnector({})

        directory.logger = mock.create_autospec(logging.Logger)
        directory.groups_client = okta.UserGroupsClient('example.com', 'xyz')

        self.directory = directory 
Example 8
Project: sketal   Author: vk-brain   File: bot.py    (license) View Source Project 6 votes vote down vote up
def init_logger(self, logger):
        if not logger:
            logger = logging.Logger("sketal", level=logging.DEBUG if self.settings.DEBUG else logging.INFO)

        formatter = logging.Formatter(fmt=u'%(filename)-10s [%(asctime)s] %(levelname)-8s: %(message)s',
                                      datefmt='%y.%m.%d %H:%M:%S')

        file_handler = logging.FileHandler('logs.txt')
        file_handler.setLevel(logging.DEBUG)
        file_handler.setFormatter(formatter)

        self.logger_file = file_handler

        stream_handler = logging.StreamHandler()
        stream_handler.setLevel(level=logging.DEBUG if self.settings.DEBUG else logging.INFO)
        stream_handler.setFormatter(formatter)

        logger.addHandler(file_handler)
        logger.addHandler(stream_handler)

        self.logger = logger 
Example 9
Project: sketal   Author: vk-brain   File: vk_api.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, vk_client, logger=None):
        if logger:
            self.logger = logger
        else:
            self.logger = logging.Logger("vk_reqque")

        self.vk_client = vk_client

        self.hold = False
        self.release = False
        self.processing = False

        self._requests_done = 0
        self.requests_done_clear_time = 0

        self.queue = asyncio.Queue() 
Example 10
Project: discover-books   Author: shispt   File: utils.py    (license) View Source Project 6 votes vote down vote up
def get_logger(name, filename, level=logging.DEBUG, fmt=None):
    logger = logging.Logger(name)

    fmt = fmt or '%(asctime)s-%(name)s-%(levelname)-10s%(message)s'
    formatter = logging.Formatter(fmt=fmt, datefmt='%Y-%m-%d %H:%M:%S')

    stream_handler = logging.StreamHandler()
    stream_handler.setFormatter(formatter)

    file_handler = logging.FileHandler(filename)
    file_handler.setFormatter(formatter)

    logger.addHandler(stream_handler)
    logger.addHandler(file_handler)

    logger.setLevel(level)

    return logger 
Example 11
Project: embeddings   Author: vzhong   File: embedding.py    (license) View Source Project 6 votes vote down vote up
def ensure_file(name, url=None, force=False, logger=logging.getLogger(), postprocess=None):
        """
        Ensures that the file requested exists in the cache, downloading it if it does not exist.

        Args:
            name (str): name of the file.
            url (str): url to download the file from, if it doesn't exist.
            force (bool): whether to force the download, regardless of the existence of the file.
            logger (logging.Logger): logger to log results.
            postprocess (function): a function that, if given, will be applied after the file is downloaded. The function has the signature ``f(fname)``

        Returns:
            str: file name of the downloaded file.

        """
        fname = Embedding.path(name)
        if not path.isfile(fname) or force:
            if url:
                logger.critical('Downloading from {} to {}'.format(url, fname))
                Embedding.download_file(url, fname)
                if postprocess:
                    postprocess(fname)
            else:
                raise Exception('{} does not exist!'.format(fname))
        return fname 
Example 12
Project: Brightside   Author: BrighterCommand   File: dispatch.py    (license) View Source Project 6 votes vote down vote up
def __init__(self,
                 connection: Connection,
                 consumer: BrightsideConsumerConfiguration,
                 consumer_factory: Callable[[Connection, BrightsideConsumerConfiguration, logging.Logger], BrightsideConsumer],
                 command_processor_factory: Callable[[str], CommandProcessor],
                 mapper_func: Callable[[BrightsideMessage], Request]) -> None:
        """
        The configuration parameters for one consumer - can create one or more performers from this, each of which is
        a message pump reading froma queue
        :param connection: The connection to the broker
        :param consumer: The consumer we want to create (routing key, queue etc)
        :param consumer_factory: A factory to create a consumer to read from a broker, a given implementation i.e. arame
        the command processor factory creates a command procesoor configured for a pipeline
        :param mapper_func: Maps between messages on the queue and requests (commnands/events)
        """
        self._connection = connection
        self._consumer = consumer
        self._consumer_factory = consumer_factory
        self._command_processor_factory = command_processor_factory
        self._mapper_func = mapper_func 
Example 13
Project: centos-base-consul   Author: zeroc0d3lab   File: __init__.py    (license) View Source Project 6 votes vote down vote up
def get_fallback_logger(stream=None):
	global _fallback_logger
	if _fallback_logger:
		return _fallback_logger

	log_format = '%(asctime)s:%(levelname)s:%(message)s'
	formatter = logging.Formatter(log_format)

	level = logging.WARNING
	handler = logging.StreamHandler(stream)
	handler.setLevel(level)
	handler.setFormatter(formatter)

	logger = logging.Logger('powerline')
	logger.setLevel(level)
	logger.addHandler(handler)
	_fallback_logger = PowerlineLogger(None, logger, '_fallback_')
	return _fallback_logger 
Example 14
Project: centos-base-consul   Author: zeroc0d3lab   File: __init__.py    (license) View Source Project 6 votes vote down vote up
def create_logger(self):
		'''Create logger

		This function is used to create logger unless it was already specified 
		at initialization.

		:return: Three objects:

			#. :py:class:`logging.Logger` instance.
			#. :py:class:`PowerlineLogger` instance.
			#. Function, output of :py:func:`gen_module_attr_getter`.
		'''
		return create_logger(
			common_config=self.common_config,
			use_daemon_threads=self.use_daemon_threads,
			ext=self.ext,
			imported_modules=self.imported_modules,
			stream=self.default_log_stream,
		) 
Example 15
Project: devsecops-example-helloworld   Author: boozallen   File: case.py    (license) View Source Project 6 votes vote down vote up
def __enter__(self):
        if isinstance(self.logger_name, logging.Logger):
            logger = self.logger = self.logger_name
        else:
            logger = self.logger = logging.getLogger(self.logger_name)
        formatter = logging.Formatter(self.LOGGING_FORMAT)
        handler = _CapturingHandler()
        handler.setFormatter(formatter)
        self.watcher = handler.watcher
        self.old_handlers = logger.handlers[:]
        self.old_level = logger.level
        self.old_propagate = logger.propagate
        logger.handlers = [handler]
        logger.setLevel(self.level)
        logger.propagate = False
        return handler.watcher 
Example 16
Project: QXSConsolas   Author: qxsch   File: Cli.py    (license) View Source Project 6 votes vote down vote up
def run(self, argv = None, data = None, logger = None):
        """
        Runs the function
        """
        if not logger is None:
            assert isinstance(logger, logging.Logger), "logger is not a valid logging.Logger"
            self.logger = logger
        if not data is None:
            assert isinstance(data, Configuration), "data is not a valid QXSConsolas.Configuration.Configuration"
            self.data = data

        self.options, self.arguments = self._argparser.parseArguments(argv)
        if self._argparser.loglevel == 1:
            self._configureConsoleLoggers(logging.NOTSET, True)
        elif self._argparser.loglevel == -1:
            self._configureConsoleLoggers(logging.CRITICAL, False)
        try:
            self._argparser.validateRequiredArguments()
            return self._app(ApplicationData(self))
        except Exception as e:
            logger.exception(e)
            return 1 
Example 17
Project: QXSConsolas   Author: qxsch   File: DeployRoles.py    (license) View Source Project 6 votes vote down vote up
def setRoleInfo(self, logger, envname, envconfig, rolename, roleconfig):
	"""
        sets the role info during deployment and backup/restores
        logger    logging.Logger
                  a logger
        envname   string
                  name of the environment, where the app should be deployed
        envconfig QXSConsolas.Configuration.Configuration
                  configuration of the environment, where the app should be deployed
        rolename   string
                   name of the environment, where the app should be deployed
        roleconfig QXSConsolas.Configuration.Configuration
                   configuration of the role, where the app shoukd be deplyed
	"""
        if isinstance(logger, logging.Logger):
            self._logger = logger
        else:
            self._logger = logging.getLogger()
        self._envname = envname
        self._envconfig = envconfig
        self._rolename = rolename
        self._roleconfig = roleconfig 
Example 18
Project: QXSConsolas   Author: qxsch   File: Cli.py    (license) View Source Project 6 votes vote down vote up
def run(self, argv = None, data = None, logger = None):
        """
        Runs the function
        """
        if not logger is None:
            assert isinstance(logger, logging.Logger), "logger is not a valid logging.Logger"
            self.logger = logger
        if not data is None:
            assert isinstance(data, Configuration), "data is not a valid QXSConsolas.Configuration.Configuration"
            self.data = data

        self.options, self.arguments = self._argparser.parseArguments(argv)
        if self._argparser.loglevel == 1:
            self._configureConsoleLoggers(logging.NOTSET, True)
        elif self._argparser.loglevel == -1:
            self._configureConsoleLoggers(logging.CRITICAL, False)
        try:
            self._argparser.validateRequiredArguments()
            return self._app(ApplicationData(self))
        except Exception as e:
            logger.exception(e)
            return 1 
Example 19
Project: virtualbmc   Author: openstack   File: log.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, debug=False, logfile=None):
        logging.Logger.__init__(self, 'VirtualBMC')
        try:
            if logfile is not None:
                self.handler = logging.FileHandler(logfile)
            else:
                self.handler = logging.StreamHandler()

            formatter = logging.Formatter(DEFAULT_LOG_FORMAT)
            self.handler.setFormatter(formatter)
            self.addHandler(self.handler)

            if debug:
                self.setLevel(logging.DEBUG)
            else:
                self.setLevel(logging.INFO)

        except IOError as e:
            if e.errno == errno.EACCES:
                pass 
Example 20
Project: mdk   Author: datawire   File: test_python.py    (license) View Source Project 6 votes vote down vote up
def test_logPassthrough(self):
        """If MDKHandler is used, logging via stdlib is passed to MDK."""
        logger = logging.Logger("mylog")
        logger.setLevel(logging.DEBUG)
        mdk, tracer = create_mdk_with_faketracer()
        session = mdk.session()
        session.trace("DEBUG")
        logger.addHandler(MDKHandler(mdk, lambda: session))

        logger.debug("debugz")
        logger.info("infoz")
        logger.warning("warnz")
        logger.error("errorz")
        logger.critical("criticalz")

        self.assertEqual(
            tracer.messages,
            [{"level": level.upper(), "category": "mylog",
              "text": level + "z", "context": session._context.traceId}
             for level in ["debug", "info", "warn", "error", "critical"]]) 
Example 21
Project: mdk   Author: datawire   File: test_python.py    (license) View Source Project 6 votes vote down vote up
def test_sessions(self):
        """
        The given session's context is used; if no session is available a default
        session is used.
        """
        mdk, tracer = create_mdk_with_faketracer()
        session1, session3 = mdk.session(), mdk.session()
        def get_session(results=[session1, None, session3]):
            return results.pop(0)

        logger = logging.Logger("mylog")
        handler = MDKHandler(mdk, get_session)
        logger.addHandler(handler)
        for i in range(3):
            logger.info("hello")
        self.assertEqual([d["context"] for d in tracer.messages],
                         [s._context.traceId for s in
                          [session1, handler._default_session, session3]]) 
Example 22
Project: mdk   Author: datawire   File: test_python.py    (license) View Source Project 6 votes vote down vote up
def tes_withinARequest(self):
        """
        When logging inside a Flask route, the MDK Session for the request is used
        if MDKLoggingHandler was set up.
        """
        logger = logging.Logger("logz")
        mdk, tracer = create_mdk_with_faketracer()
        app = make_flask_app(logger)
        mdk_setup(app, mdk=mdk)

        handler = MDKLoggingHandler(mdk)
        logger.addHandler(handler)
        client = app.test_client()
        client.get("/")
        message = tracer.messages[-1]
        self.assertEqual("hello: " + message["context"], message["text"]) 
Example 23
Project: integration-prototype   Author: SKA-ScienceDataProcessor   File: heap_streamer.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, config, frame_shape, log=Logger(__name__)):
        """Creates and sets up SPEAD streams.

        The configuration of streams is passed in via the ``config`` arguent.

        The dimensions of the visibility data must be specified in order
        to initialise the payload. This is a tuple of dimensions defined in the
        ICD as:


        Args:
            config (dict): Dictionary of settings (see above).
            frame_shape (tuple): Dimensions of the payload visibility data.
            log (logging.Logger): Python logging object.
        """
        self._config = config
        self._frame_shape = frame_shape
        self._log = log
        self._heap_descriptor = self._init_heap_descriptor()
        self._streams = list()
        self._heap_counter = 0
        self._send_timer = 0
        self._heap_size = self._get_heap_size()
        self._create_streams()
        self._payload = self._init_payload() 
Example 24
Project: robot-camera-platform   Author: danionescu0   File: LoggingConfig.py    (license) View Source Project 6 votes vote down vote up
def get_logger(self) -> logging.Logger:
        formatter = logging.Formatter(fmt='%(levelname)s (%(threadName)-10s) :%(name)s: %(message)s '
                                  '(%(asctime)s; %(filename)s:%(lineno)d)',
                              datefmt="%Y-%m-%d %H:%M:%S")
        handlers = [
            logging.handlers.RotatingFileHandler(self.__filename,
                                                 encoding='utf8',
                                                 maxBytes=self.__max_bytes,
                                                 backupCount=3),
            logging.StreamHandler()
        ]
        self.__root_logger = logging.getLogger()
        if (self.__debug):
            level = logging.DEBUG
        else:
            level = logging.WARNING

        self.__root_logger.setLevel(level)
        for h in handlers:
            h.setFormatter(formatter)
            h.setLevel(level)
            self.__root_logger.addHandler(h)

        return self.__root_logger 
Example 25
Project: calmjs   Author: calmjs   File: utils.py    (license) View Source Project 6 votes vote down vote up
def enable_pretty_logging(logger='calmjs', level=logging.DEBUG, stream=None):
    """
    Shorthand to enable pretty logging
    """

    def cleanup():
        logger.removeHandler(handler)
        logger.level = old_level

    if not isinstance(logger, logging.Logger):
        logger = logging.getLogger(logger)

    old_level = logger.level
    handler = logging.StreamHandler(stream)
    handler.setFormatter(logging.Formatter(
        u'%(asctime)s %(levelname)s %(name)s %(message)s'))
    logger.addHandler(handler)
    logger.setLevel(level)
    return cleanup 
Example 26
Project: openbrokerapi   Author: eruvanos   File: api.py    (license) View Source Project 6 votes vote down vote up
def serve(services: List[Service],
          credentials: BrokerCredentials,
          logger: logging.Logger = logging.root,
          port=5000,
          debug=False):
    """
    Starts flask with the given broker

    :param services: Services that this broker provides
    :param credentials: Username and password that will be required to communicate with service broker
    :param logger: Used for api logs. This will not influence Flasks logging behavior
    :param port: Port
    :param debug: Enables debugging in flask app
    """

    from flask import Flask
    app = Flask(__name__)

    blueprint = get_blueprint(services, credentials, logger)

    logger.debug("Register openbrokerapi blueprint")
    app.register_blueprint(blueprint)

    logger.info("Start Flask on 0.0.0.0:%s" % port)
    app.run('0.0.0.0', port, debug) 
Example 27
Project: leetcode   Author: thomasyimgit   File: loader.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, log=None):
        """A base class for config loaders.

        log : instance of :class:`logging.Logger` to use.
              By default loger of :meth:`traitlets.config.application.Application.instance()`
              will be used

        Examples
        --------

        >>> cl = ConfigLoader()
        >>> config = cl.load_config()
        >>> config
        {}
        """
        self.clear()
        if log is None:
            self.log = self._log_default()
            self.log.debug('Using default logger')
        else:
            self.log = log 
Example 28
Project: zippy   Author: securesystemslab   File: test_logging.py    (license) View Source Project 6 votes vote down vote up
def test_persistent_loggers(self):
        # Logger objects are persistent and retain their configuration, even
        #  if visible references are destroyed.
        self.root_logger.setLevel(logging.INFO)
        foo = logging.getLogger("foo")
        self._watch_for_survival(foo)
        foo.setLevel(logging.DEBUG)
        self.root_logger.debug(self.next_message())
        foo.debug(self.next_message())
        self.assert_log_lines([
            ('foo', 'DEBUG', '2'),
        ])
        del foo
        # foo has survived.
        self._assertTruesurvival()
        # foo has retained its settings.
        bar = logging.getLogger("foo")
        bar.debug(self.next_message())
        self.assert_log_lines([
            ('foo', 'DEBUG', '2'),
            ('foo', 'DEBUG', '3'),
        ]) 
Example 29
Project: aws-ec2rescue-linux   Author: awslabs   File: logutil.py    (license) View Source Project 6 votes vote down vote up
def set_direct_console_logger(cls, loglevel=logging.INFO):
        """
        Configure and add the handler for the direct console logger.

        Parameters:
            loglevel (int): numeric value of the logging level (e.g. DEBUG == 10)

        Returns:
            logger (Logger): the root logger's child named 'console'
        """
        logger = cls.get_root_logger().getChild("console")
        logger.setLevel(logging.DEBUG)
        consolehandler = logging.StreamHandler()
        consolehandler.setLevel(loglevel)
        logger.addHandler(consolehandler)
        logger.propagate = True
        return logger 
Example 30
Project: aws-ec2rescue-linux   Author: awslabs   File: logutil.py    (license) View Source Project 6 votes vote down vote up
def get_module_logger(cls, mod, logdir):
        """
        Returns a logging.Logger specific to the given module.
        If the logger has not yet been configured, it will be created with default options
        by LogUtil.create_module_logger()

        Parameters:
            mod (Module): module to return a logger for
            logdir (str): the log directory path

        Returns:
            (logger): logging.Logger specific to the given ec2rlcore.module
        """
        if "{}:{}".format(mod.placement, mod.name) not in cls._module_loggers:
            cls.create_module_logger(mod, logdir)

        return logging.getLogger("ec2rl").getChild("module").getChild(mod.placement).getChild(mod.name) 
Example 31
Project: odooku-compat   Author: adaptivdesign   File: logger.py    (license) View Source Project 6 votes vote down vote up
def log(self, lvl, msg, *args, **kwargs):
        try:
            extra = kwargs.get("extra", None)
            if extra is not None:
                metric = extra.get(METRIC_VAR, None)
                value = extra.get(VALUE_VAR, None)
                typ = extra.get(MTYPE_VAR, None)
                if metric and value and typ:
                    if typ == GAUGE_TYPE:
                        self.gauge(metric, value)
                    elif typ == COUNTER_TYPE:
                        self.increment(metric, value)
                    elif typ == HISTOGRAM_TYPE:
                        self.histogram(metric, value)
                    else:
                        pass
        except Exception:
            logging.Logger.warning(self, "Failed to log to statsd", exc_info=True)

        if msg:
            logging.Logger.log(self, lvl, msg, *args, **kwargs) 
Example 32
Project: TrezorSymmetricFileEncryption   Author: 8go   File: settings.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, logger=None, mlogger=None):
		"""
		@param logger: holds logger for where to log info/warnings/errors
			If None, a default logger will be created.
		@type logger: L{logging.Logger}
		@param mlogger: holds mlogger for where to log info/warnings/errors
			If None, a default mlogger will be created.
		@type mlogger: L{utils.MLogger}
		"""
		super(Settings, self).__init__(logger, mlogger)
		self.TArg = False
		self.EArg = False
		self.OArg = False
		self.DArg = False
		self.MArg = False
		self.NArg = False
		self.XArg = False  # -2, --twice
		self.PArg = None
		self.RArg = None  # -r read PIN
		self.AArg = None  # -R read passphrase
		self.SArg = False  # Safety check
		self.WArg = False  # Wipe plaintxt after encryption
		self.QArg = False  # noconfirm
		self.inputFiles = []  # list of input filenames 
Example 33
Project: TrezorSymmetricFileEncryption   Author: 8go   File: utils.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, terminalMode=None, logger=None, qtextbrowser=None):
		"""
		Get as many necessary parameters upfront as possible, so the user
		does not have to provide them later on each call.

		@param terminalMode: log only to terminal?
		@type terminalMode: C{bool}
		@param logger: holds logger for where to log info/warnings/errors
		@type logger: L{logging.Logger}
		@param qtextbrowser: holds GUI widget for where to log info/warnings/errors
		@type qtextbrowser: L{PyQt5.QtWidgets.QTextBrowser}
		"""
		self.terminalMode = terminalMode
		self.logger = logger
		self.qtextbrowser = qtextbrowser
		# qtextbrowser text will be created by assembling:
		# qtextheader + qtextContent + qtextTrailer
		self.qtextheader = u''
		self.qtextcontent = u''
		self.qtexttrailer = u'' 
Example 34
Project: alfred-mpd   Author: deanishe   File: workflow.py    (license) View Source Project 5 votes vote down vote up
def logger(self, logger):
        """Set a custom logger.

        :param logger: The logger to use
        :type logger: `~logging.Logger` instance

        """
        self._logger = logger 
Example 35
Project: Starfish   Author: BillWang139967   File: log.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def getLogger():
        # ??log????????,?????????????????
        # ??a?????log???b????a????????????
        # ?????????????
        if Logger.logger is not None:
            return Logger.logger
        Logger.logger = logging.Logger(Logger.log_name) 
       
        if Logger.log_print == "True":
            print_handler = logging.StreamHandler()
            print_fmt = logging.Formatter(
                    Logger.log_formatter, 
                    datefmt=Logger.log_formatter_datefmt
                    )   
            print_handler.setFormatter(print_fmt)   
            Logger.logger.addHandler(print_handler)
       
        file_handler = logging.handlers.RotatingFileHandler(
                filename = Logger.log_file,
                maxBytes = Logger.log_max_byte,
                backupCount = Logger.log_backup_count
                )
        file_fmt = logging.Formatter(
                Logger.log_formatter, 
                datefmt=Logger.log_formatter_datefmt
                )
        file_handler.setFormatter(file_fmt)
        Logger.logger.addHandler(file_handler)
        
        Logger.logger.setLevel(Logger.levels.get(Logger.log_level))
        return Logger.logger 
Example 36
Project: Starfish   Author: BillWang139967   File: log.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def getLogger():
        # ??log????????,?????????????????
        # ??a?????log???b????a????????????
        # ?????????????
        if Logger.logger is not None:
            return Logger.logger
        Logger.logger = logging.Logger(Logger.log_name) 
       
        if Logger.log_print == "True":
            print_handler = logging.StreamHandler()
            print_fmt = logging.Formatter(
                    Logger.log_formatter, 
                    datefmt=Logger.log_formatter_datefmt
                    )   
            print_handler.setFormatter(print_fmt)   
            Logger.logger.addHandler(print_handler)
       
        file_handler = logging.handlers.RotatingFileHandler(
                filename = Logger.log_file,
                maxBytes = Logger.log_max_byte,
                backupCount = Logger.log_backup_count
                )
        file_fmt = logging.Formatter(
                Logger.log_formatter, 
                datefmt=Logger.log_formatter_datefmt
                )
        file_handler.setFormatter(file_fmt)
        Logger.logger.addHandler(file_handler)
        
        Logger.logger.setLevel(Logger.levels.get(Logger.log_level))
        return Logger.logger 
Example 37
Project: wmd-relax   Author: src-d   File: __init__.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, embeddings, nbow, vocabulary_min=50, vocabulary_max=500,
                 vocabulary_optimizer=TailVocabularyOptimizer(),
                 verbosity=logging.INFO, main_loop_log_interval=60):
        """
        Initializes a new instance of WMD class.

        :param embeddings: The embeddings model, see WMD.embeddings.
        :param nbow: The nBOW model, see WMD.nbow.
        :param vocabulary_min: The minimum bag size, see \
                               :py:attr:`~wmd.WMD.vocabulary_min`.
        :param vocabulary_max: The maximum bag size, see \
                               :py:attr:`~wmd.WMD.vocabulary_max`.
        :param vocabulary_optimizer: The bag size reducer, see \
                                     :py:attr:`~wmd.WMD.vocabulary_optimizer`.
        :param verbosity: The log verbosity level.
        :param main_loop_log_interval: Time frequency of logging updates, see \
                                       :py:attr:`~wmd.WMD.main_loop_log_interval`.
        :type embeddings: object with :meth:`~object.__getitem__`
        :type nbow: object with :meth:`~object.__iter__` and \
                    :meth:`~object.__getitem__`
        :type vocabulary_min: int
        :type vocabulary_max: int
        :type vocabulary_optimizer: callable
        :type verbosity: int
        :type main_loop_log_interval: int
        :raises TypeError: if some of the arguments are invalid.
        :raises ValueError: if some of the arguments are invalid.
        """
        self._relax_cache = None
        self._exact_cache = None
        self._centroid_cache = None
        self.embeddings = embeddings
        self.nbow = nbow
        self.vocabulary_min = vocabulary_min
        self.vocabulary_max = vocabulary_max
        self.vocabulary_optimizer = vocabulary_optimizer
        self._log = logging.getLogger("WMD")
        self._log.level = logging.Logger("", verbosity).level
        self.main_loop_log_interval = main_loop_log_interval 
Example 38
Project: Chainmail   Author: Chainmail-Project   File: Plugin.py    (MIT License) View Source Project 5 votes vote down vote up
def logger(self) -> logging.Logger:
        """
        Gets the logger belonging to this plugin
        :return: The logger
        """
        if self._logger is None:
            self._logger = logging.getLogger(self.manifest.get("name"))
        return self._logger 
Example 39
Project: Gank-Alfred-Workflow   Author: hujiaweibujidao   File: workflow.py    (MIT License) View Source Project 5 votes vote down vote up
def logger(self):
        """Create and return a logger that logs to both console and
        a log file.

        Use :meth:`open_log` to open the log file in Console.

        :returns: an initialised :class:`~logging.Logger`

        """

        if self._logger:
            return self._logger

        # Initialise new logger and optionally handlers
        logger = logging.getLogger('workflow')

        if not len(logger.handlers):  # Only add one set of handlers

            fmt = logging.Formatter(
                '%(asctime)s %(filename)s:%(lineno)s'
                ' %(levelname)-8s %(message)s',
                datefmt='%H:%M:%S')

            logfile = logging.handlers.RotatingFileHandler(
                self.logfile,
                maxBytes=1024*1024,
                backupCount=1)
            logfile.setFormatter(fmt)
            logger.addHandler(logfile)

            # console = logging.StreamHandler()
            # console.setFormatter(fmt)
            # logger.addHandler(console)

        logger.setLevel(logging.DEBUG)
        self._logger = logger

        return self._logger 
Example 40
Project: Gank-Alfred-Workflow   Author: hujiaweibujidao   File: workflow.py    (MIT License) View Source Project 5 votes vote down vote up
def logger(self, logger):
        """Set a custom logger.

        :param logger: The logger to use
        :type logger: `~logging.Logger` instance

        """

        self._logger = logger 
Example 41
Project: Gank-Alfred-Workflow   Author: hujiaweibujidao   File: workflow.py    (MIT License) View Source Project 5 votes vote down vote up
def logger(self):
        """Create and return a logger that logs to both console and
        a log file.

        Use :meth:`open_log` to open the log file in Console.

        :returns: an initialised :class:`~logging.Logger`

        """

        if self._logger:
            return self._logger

        # Initialise new logger and optionally handlers
        logger = logging.getLogger('workflow')

        if not len(logger.handlers):  # Only add one set of handlers

            fmt = logging.Formatter(
                '%(asctime)s %(filename)s:%(lineno)s'
                ' %(levelname)-8s %(message)s',
                datefmt='%H:%M:%S')

            logfile = logging.handlers.RotatingFileHandler(
                self.logfile,
                maxBytes=1024*1024,
                backupCount=1)
            logfile.setFormatter(fmt)
            logger.addHandler(logfile)

            # console = logging.StreamHandler()
            # console.setFormatter(fmt)
            # logger.addHandler(console)

        logger.setLevel(logging.DEBUG)
        self._logger = logger

        return self._logger 
Example 42
Project: Gank-Alfred-Workflow   Author: hujiaweibujidao   File: workflow.py    (MIT License) View Source Project 5 votes vote down vote up
def logger(self, logger):
        """Set a custom logger.

        :param logger: The logger to use
        :type logger: `~logging.Logger` instance

        """

        self._logger = logger 
Example 43
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: log_test.py    (MIT License) View Source Project 5 votes vote down vote up
def setUp(self):
        super(EnablePrettyLoggingTest, self).setUp()
        self.options = OptionParser()
        define_logging_options(self.options)
        self.logger = logging.Logger('tornado.test.log_test.EnablePrettyLoggingTest')
        self.logger.propagate = False 
Example 44
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: log_test.py    (MIT License) View Source Project 5 votes vote down vote up
def setUp(self):
        self.formatter = LogFormatter(color=False)
        # Fake color support.  We can't guarantee anything about the $TERM
        # variable when the tests are run, so just patch in some values
        # for testing.  (testing with color off fails to expose some potential
        # encoding issues from the control characters)
        self.formatter._colors = {
            logging.ERROR: u("\u0001"),
        }
        self.formatter._normal = u("\u0002")
        # construct a Logger directly to bypass getLogger's caching
        self.logger = logging.Logger('LogFormatterTest')
        self.logger.propagate = False
        self.tempdir = tempfile.mkdtemp()
        self.filename = os.path.join(self.tempdir, 'log.out')
        self.handler = self.make_handler(self.filename)
        self.handler.setFormatter(self.formatter)
        self.logger.addHandler(self.handler) 
Example 45
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: log_test.py    (MIT License) View Source Project 5 votes vote down vote up
def setUp(self):
        super(EnablePrettyLoggingTest, self).setUp()
        self.options = OptionParser()
        define_logging_options(self.options)
        self.logger = logging.Logger('tornado.test.log_test.EnablePrettyLoggingTest')
        self.logger.propagate = False 
Example 46
Project: noc-orchestrator   Author: DirceuSilvaLabs   File: log_test.py    (MIT License) View Source Project 5 votes vote down vote up
def setUp(self):
        self.formatter = LogFormatter(color=False)
        # Fake color support.  We can't guarantee anything about the $TERM
        # variable when the tests are run, so just patch in some values
        # for testing.  (testing with color off fails to expose some potential
        # encoding issues from the control characters)
        self.formatter._colors = {
            logging.ERROR: u("\u0001"),
        }
        self.formatter._normal = u("\u0002")
        # construct a Logger directly to bypass getLogger's caching
        self.logger = logging.Logger('LogFormatterTest')
        self.logger.propagate = False
        self.tempdir = tempfile.mkdtemp()
        self.filename = os.path.join(self.tempdir, 'log.out')
        self.handler = self.make_handler(self.filename)
        self.handler.setFormatter(self.formatter)
        self.logger.addHandler(self.handler) 
Example 47
Project: aio-service-client   Author: alfred82santa   File: factories.py    (GNU Lesser General Public License v3.0) View Source Project 5 votes vote down vote up
def __call__(self, logger, **kwargs):
        try:
            logger = self.load_item(logger, Logger)
        except TypeError:  # pragma: no cover
            pass

        return super(LoggerPluginFactory, self).__call__(logger=logger, **kwargs) 
Example 48
Project: gemstone   Author: vladcalin   File: microservice.py    (MIT License) View Source Project 5 votes vote down vote up
def get_logger(self):
        """
        Override this method to designate the logger for the application

        :return: a :py:class:`logging.Logger` instance
        """
        enable_pretty_logging()
        return logging.getLogger("tornado.application")

    # endregion

    # region Can be called by user 
Example 49
Project: darkc0de-old-stuff   Author: tuwid   File: scanner.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def __init__(self, verbosity=5):
        self.udp_ts = UDPTransceiver()
        self.iax_proto = IAXProto()
        self.log = Logger(verbosity).log

        self.liveUsers = [] 
Example 50
Project: darkc0de-old-stuff   Author: tuwid   File: scanner.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def __init__(self, verbosity=5):
        self.udp_ts = UDPTransceiver()
        self.iax_proto = IAXProto()
        self.log = Logger(verbosity).log
        
        self.liveHosts = []