Log the configuration settings. Shown when exception thrown or when verbose
is true.
481443
protected void logConfiguration() throws MojoExecutionException {
		super.logConfiguration();
		// TODO clean up
		getLog().info("catalogURIs (calculated):" + getCatalogURIs());
		getLog().info("resolvedCatalogURIs (calculated):" + getResolvedCatalogURIs());
		getLog().info("schemaFiles (calculated):" + getSchemaFiles());
		getLog().info("schemaURIs (calculated):" + getSchemaURIs());
		getLog().info("resolvedSchemaURIs (calculated):" + getResolvedSchemaURIs());
		getLog().info("bindingFiles (calculated):" + getBindingFiles());
		getLog().info("bindingURIs (calculated):" + getBindingURIs());
		getLog().info("resolvedBindingURIs (calculated):" + getResolvedBindingURIs());
		getLog().info("xjcPluginArtifacts (resolved):" + getXjcPluginArtifacts());
		getLog().info("xjcPluginFiles (resolved):" + getXjcPluginFiles());
		getLog().info("xjcPluginURLs (resolved):" + getXjcPluginURLs());
		getLog().info("episodeArtifacts (resolved):" + getEpisodeArtifacts());
		getLog().info("episodeFiles (resolved):" + getEpisodeFiles());
		getLog().info("dependsURIs (resolved):" + getDependsURIs());
	}
171043
def configure_logging(conf):
    """"""
    logging.config.dictConfig({
        'version': 1,
        'disable_existing_loggers': False,
        'formatters': {
            'standard': {
                'format': '%(asctime)s [%(name)s] %(levelname)s '
                          '%(processName)s: %(message)s'
            }
        },
        'handlers': {
            'file': {
                'level': conf.LOG_FILE_LEVEL,
                'filename': conf.LOG_FILE,
                'class': 'logging.FileHandler',
                'formatter': 'standard',
            },
            'stdout': {
                'level': conf.LOG_STDOUT_LEVEL,
                'class': 'pyphi.log.TqdmHandler',
                'formatter': 'standard',
            }
        },
        'root': {
            'level': 'DEBUG',
            'handlers': (['file'] if conf.LOG_FILE_LEVEL else []) +
                        (['stdout'] if conf.LOG_STDOUT_LEVEL else [])
        }
    })
761015
def log_config(self):
        '''  '''
        level = self.level
        debug = self.debug
        debug('Logging config:')
        debug('/ name: {}, id: {}', self.name, id(self))
        debug('  .level: %s (%s)', level_map_int[level], level)
        debug('  .default_level: %s (%s)',
                   level_map_int[self.default_level], self.default_level)

        for i, handler in enumerate(self.handlers):
            fmtr = handler.formatter
            debug('  + Handler: %s %r', i, handler)
            debug('    + Formatter: %r', fmtr)
            debug('      .datefmt: %r', fmtr.datefmt)
            debug('      .msgfmt: %r', fmtr._fmt)
            debug('      fmt_style: %r', fmtr._style)
            try:
                debug('      theme styles: %r', fmtr._theme_style)
                debug('      theme icons:\n%r', fmtr._theme_icons)
                debug('      lexer: %r\n', fmtr._lexer)
            except AttributeError:
                pass
970126
def log_config(self, value):
        
        if not isinstance(value, dict):
            raise TypeError("log_config must be a dict. {0} was passed".format(value))

        config      = value.get('config')
        driver_type = value.get('type')

        if driver_type not in VALID_LOG_DRIVER_TYPES:
            raise ValueError("type must be one of the support drivers {0}".format(", ".join(VALID_LOG_DRIVER_TYPES)))

        if config and not isinstance(config, dict):
            raise ValueError("log_config.config must be a dict.")

        if driver_type == 'syslog':
            config = {
                'syslog-facility': config.get('syslog_facility', config.get('syslog-facility')),
                'syslog-tag': config.get('syslog_tag', config.get('syslog-tag'))
            }

        self._log_config = {'type': driver_type, 'config': config or {}}
1229672
def configure_logging(verbosity):
    

    root = logging.getLogger()

    formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(levelname).3s %(name)s %(message)s',
                                  '%y-%m-%d %H:%M:%S')
    handler = logging.StreamHandler()
    handler.setFormatter(formatter)

    loglevels = [logging.CRITICAL, logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
    if verbosity >= len(loglevels):
        verbosity = len(loglevels) - 1

    level = loglevels[verbosity]

    root.setLevel(level)
    root.addHandler(handler)
346190
def config_logging(debug: bool = False) -> None:
    
    if debug:
        level = 'DEBUG'
        tf_level = tf.logging.INFO
    else:
        level = 'INFO'
        tf_level = tf.logging.ERROR

    logging_config = config_dict('logging.json')
    for logger in logging_config['loggers'].values():
        logger['level'] = level

    logging.config.dictConfig(logging_config)
    tf.logging.set_verbosity(tf_level)
1234142
def initialise_logging(level: str, target: str, short_format: bool):
    """"""
    try:
        log_level = getattr(logging, level)
    except AttributeError:
        raise SystemExit(
            "invalid log level %r, expected any of 'DEBUG', 'INFO', 'WARNING', 'ERROR' or 'CRITICAL'" % level
        )
    handler = create_handler(target=target)
    logging.basicConfig(
        level=log_level,
        format='%(asctime)-15s (%(process)d) %(message)s' if not short_format else '%(message)s',
        datefmt='%Y-%m-%d %H:%M:%S',
        handlers=[handler]
    )
1288240
def configure_logging(self):
        """"""
        root_logger = logging.getLogger('')

        # Set up logging to a file
        root_logger.setLevel(logging.DEBUG)

        # Send higher-level messages to the console via stderr
        console = logging.StreamHandler(self.stderr)
        console_level = {self.WARNING_LEVEL: logging.WARNING,
                         self.INFO_LEVEL: logging.INFO,
                         self.DEBUG_LEVEL: logging.DEBUG,
                         }.get(self.options.verbose_level, logging.DEBUG)
        # The default log level is INFO, in this situation, set the
        # log level of the console to WARNING, to avoid displaying
        # useless messages. This equals using "--quiet"
        if console_level == logging.INFO:
            console.setLevel(logging.WARNING)
        else:
            console.setLevel(console_level)
        if logging.DEBUG == console_level:
            formatter = logging.Formatter(self.DEBUG_MESSAGE_FORMAT)
        else:
            formatter = logging.Formatter(self.CONSOLE_MESSAGE_FORMAT)
        logging.getLogger('iso8601.iso8601').setLevel(logging.WARNING)
        logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)
        console.setFormatter(formatter)
        root_logger.addHandler(console)
        return
949212
public void configure(Configuration config) throws ConfigurationException
    {
        LoggingConfiguration lc = (LoggingConfiguration) config;
        String levelName = lc.getLogLevel(name);
        setLevel(levelName);
    }
932577
def show_configure(self):
        
        logging.info("Displaying configuration window")
        if self.configWindow is None:
            self.configWindow = ConfigWindow(self)
            self.configWindow.show()
        else:
            self.configWindow.deiconify()
599643
private void logConfigurationError(String message, Throwable t) {

        setValidConfiguration(false);
        if (LOG.isErrorEnabled()) {
            if (t == null) {
                LOG.error(Messages.get().getBundle().key(Messages.LOG_EDITOR_CONFIG_ERROR_1, message));
            } else {
                LOG.error(Messages.get().getBundle().key(Messages.LOG_EDITOR_CONFIG_ERROR_1, message), t);
            }
        }
    }
456689
protected void reportErrors(Parameterization config) {
    StringBuilder buf = new StringBuilder();
    for(ParameterException e : config.getErrors()) {
      if(e instanceof UnspecifiedParameterException) {
        continue;
      }
      buf.append(e.getMessage()).append(FormatUtil.NEWLINE);
    }
    if(buf.length() > 0) {
      LOG.warning("Configuration errors:" + FormatUtil.NEWLINE + FormatUtil.NEWLINE + buf.toString());
    }
    // config.clearErrors();
  }
656682
protected static function configureLogging()
    {
        if (self::$logger === null) {
            if (isset(self::$configuration['log']) && is_array(self::$configuration['log']) && count(self::$configuration['log'])) {
                include_once 'Log.php'; // PEAR Log class
                $c = self::$configuration['log'];
                $type = isset($c['type']) ? $c['type'] : 'file';
                $name = isset($c['name']) ? $c['name'] : './propel.log';
                $ident = isset($c['ident']) ? $c['ident'] : 'propel';
                $conf = isset($c['conf']) ? $c['conf'] : array();
                $level = isset($c['level']) ? $c['level'] : PEAR_LOG_DEBUG;
                self::$logger = Log::singleton($type, $name, $ident, $conf, $level);
            } // if isset()
        }
    }
707851
def setup_logging(fail_silently=False):
    
    config = None

    paths = list(get_config_paths(filename='logconfig.yml', reversed=True))
    for path in paths:
        if not os.path.exists(path):
            continue

        with open(path, 'rt') as f:
            config = yaml.safe_load(f.read())

        LOG_LEVEL = os.environ.get('LOG_LEVEL')
        if LOG_LEVEL:
            config['root']['level'] = LOG_LEVEL.upper()
            config['handlers']['console']['level'] = LOG_LEVEL.upper()

        logging.config.dictConfig(config)

        break
    else:
        if not fail_silently:
            raise LogconfigError('Unable to find logconfig in {}'.format(paths))

    return config
455586
public void log(Throwable exception) {
		if (exception instanceof CoreException) {
			getILog().log(new Status(IStatus.ERROR, PLUGIN_ID,
					exception.getMessage(),
					exception.getCause()));
		} else if (exception != null) {
			getILog().log(new Status(IStatus.ERROR, PLUGIN_ID,
					exception.getMessage(), exception));
		} else {
			getILog().log(new Status(IStatus.ERROR, PLUGIN_ID,
					"Internal Error", exception));   //$NON-NLS-1$
		}
	}
1042471
def log_exception(self, exc_info):
        """"""
        dsn = self.config.get("SENTRY_DSN")
        if not dsn:
            super().log_exception(exc_info)
1275270
def _log_exception(self, exception):
        
        self._io.error(str(exception).strip().split(os.linesep))