Java Code Examples for ch.qos.logback.classic.Level#toLevel()

@Override
public void setLoggerLevel(String loggerName, String levelStr) {
    if (loggerName == null) {
        return;
    }
    if (levelStr == null) {
        return;
    }
    loggerName = loggerName.trim();
    levelStr = levelStr.trim();

    LOGGER.info("Jmx Trying to set logger level [" + levelStr + "] to logger [" + loggerName +"]");

    ch.qos.logback.classic.Logger logger = loggerContext.getLogger(loggerName);
    if ("null".equalsIgnoreCase(levelStr)) {
        logger.setLevel(null);
    } else {
        Level level = Level.toLevel(levelStr, null);
        if (level != null) {
            logger.setLevel(level);
        }
    }
}
 

@POST
@Produces(MediaType.TEXT_HTML)
public String post(
    @FormParam("logger") String loggerName,
    @FormParam("level") String loggerLevel) throws TemplateException {

  Optional<String> configChange = Optional.empty();
  if (loggerName != null && loggerLevel != null) {
    Logger logger = (Logger) LoggerFactory.getLogger(loggerName);
    Level newLevel = Level.toLevel(loggerLevel, null);
    logger.setLevel(newLevel);

    configChange = Optional.of(String.format("%s level changed to %s", loggerName, loggerLevel));
  }

  return displayPage(configChange);
}
 

public static Boolean updateLevel(String name, String level) {
    if (Logback) {
        try {
            Level l = Level.toLevel(level, Level.ERROR);
            LoggerContext loggerContext = (LoggerContext) loggerFactoryInstance;

            Logger logger = loggerContext.exists(name);
            if (logger != null) {
                logger.setLevel(l);
                return true;
            }
        } catch (Throwable t) {
            // ignore
        }
        return false;
    }
    return null;
}
 

@PUT
@Path("levels")
@Consumes(MediaType.APPLICATION_JSON)
public Response setLogLevels(List<LogLevel> levels) throws JsonProcessingException
{
    LoggerContext loggerContext = getLoggerContext();
    for ( LogLevel logLevel : levels )
    {
        ch.qos.logback.classic.Logger logger = loggerContext.getLogger(logLevel.getName());
        if ( logger != null )
        {
            Level newLevel = Level.toLevel(logLevel.getLevel(), null);
            logger.setLevel(newLevel);
            log.info(String.format("Setting log level. Name (%s) - Level (%s)", logLevel.getName(), logLevel.getLevel()));
        }
        else
        {
            log.warn("Logger not found for: " + logLevel.getName());
        }
    }
    return Response.ok().build();
}
 

private static Map<LogEnum, Level> constructModuleLoglevelMap(Map<LogEnum, LogLevel> _moduleToLevelMap) {
    Map<LogEnum, Level> modules = new HashMap<>();
    for (LogEnum mod : LogEnum.values()) {
        LogLevel modLevel = _moduleToLevelMap.get(mod);
        if (modLevel != null) {
            // if we can't translate log-level for some reason, default to WARN
            Level level = Level.toLevel(modLevel.name(), Level.WARN);
            modules.put(mod, level);
        } else {
            modules.put(mod, Level.WARN);
        }
    }

    return modules;
}
 

private static void configureLogging(String level, String logPath)
{
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    JoranConfigurator configurator = new JoranConfigurator();
    configurator.setContext(context);
    context.reset();

    // logback uses system property to embed variables in XML file
    Level lv = Level.toLevel(level.toUpperCase(), Level.DEBUG);
    System.setProperty("digdag.log.level", lv.toString());

    String name;
    if (logPath.equals("-")) {
        if (System.console() != null) {
            name = "/digdag/cli/logback-color.xml";
        } else {
            name = "/digdag/cli/logback-console.xml";
        }
    } else {
        System.setProperty("digdag.log.path", logPath);
        name = "/digdag/cli/logback-file.xml";
    }
    try {
        configurator.doConfigure(Main.class.getResource(name));
    } catch (JoranException ex) {
        throw new RuntimeException(ex);
    }
}
 

private void setLoggerLevel(String loggerConfig) {
  String[] parts = loggerConfig.split("=", 2);

  if (parts.length < 2) {
    return;
  }
  String loggerName = parts[0];
  String levelStr = parts[1];

  if (levelStr.isEmpty() || loggerName.isEmpty()) {
    return;
  }

  loggerName = loggerName.trim();
  levelStr = levelStr.trim();

  LoggerContext lc = (LoggerContext) context;

  Logger logger = lc.getLogger(loggerName);
  if ("null".equalsIgnoreCase(levelStr)) {
    logger.setLevel(null);
  } else {
    Level level = Level.toLevel(levelStr, null);
    if (level != null) {
      logger.setLevel(level);
    }
  }
}
 

public void changeLevel(String level, String loggerName){
		LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
		Logger targetLogger = loggerContext.getLogger(loggerName);
		if(targetLogger==null || StringUtils.isBlank(level)){
			throw new ServiceException("logger not found or error level! logger: " + loggerName + ", level: " + level);
		}
		Level targetLevel = Level.toLevel(level);
		if(targetLevel.equals(targetLogger.getLevel())){
//			throw new ServiceException("logger's level is equals target level");
			return ;
		}
		loggerOriginLevelHoders.putIfAbsent(targetLogger, Optional.ofNullable(targetLogger.getLevel()));
		targetLogger.setLevel(targetLevel);
		logger.info("logger[{}] change level to {}", loggerName, level);
	}
 

@Override
public Level convert(String value) {
  Level res = Level.toLevel(value, Level.OFF);

  if (!res.levelStr.equalsIgnoreCase(value)) {
    throw new IllegalArgumentException(
        "Log level "
            + value
            + " is not valid. The options are: OFF, ERROR, WARN, INFO, DEBUG, TRACE, or ALL.");
  }

  return res;
}
 

private Level convertToLevel(String s) {
  if (Strings.isNullOrEmpty(s)) {
    return null;
  } else {
    return Level.toLevel(s);
  }
}
 

@SuppressWarnings("java:S4792") // Logger configuration is ok
public void setLogLevel(final String logLevel) {
    final Level level = Level.toLevel(logLevel);
    getLogger().setLevel(level);
}
 

private static void setLoggingLevel() {
    Level level = Level.toLevel(AppSettings.getInstance().getString(AppSettings.LOGGING_LEVEL));
    final Logger logger = org.slf4j.LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) logger;
    logbackLogger.setLevel(level);
}
 

public Level pluginLoggingLevel(String pluginId) {
    return Level.toLevel(getPropertyImpl("plugin." + pluginId + ".log.level", "INFO"), Level.INFO);
}
 

public Level getEffectiveLevel() {
    return Level.toLevel(this.effectiveLevelInt);
}
 

@Override
protected void postResolve()
{
    super.postResolve();
    _filter = new LoggerNameAndLevelFilter(getLoggerName(), Level.toLevel(getLevel().name()));
}
 

@Override
protected void postResolve()
{
    super.postResolve();
    _filter = new PredicateAndLoggerNameAndLevelFilter(getLoggerName(), Level.toLevel(getLevel().name()), getPredicate());
}
 

@Override
protected boolean handlePut(HttpServletRequest request,
		HttpServletResponse response, ILogService logService, IPath path)
		throws ServletException {

	URI baseLocation = getURI(request);

	try {
		String loggerName = path.segment(0);
		JSONObject toPut = OrionServlet.readJSONRequest(request);

		Logger logger = logService.getLogger(loggerName);
		if (logger == null) {
			final String msg = NLS
					.bind("Logger not found: {0}", loggerName);
			final ServerStatus error = new ServerStatus(IStatus.ERROR,
					HttpServletResponse.SC_NOT_FOUND, msg, null);
			return statusHandler.handleRequest(request, response, error);
		}

		String putlevel = toPut.getString(LogConstants.KEY_LOGGER_LEVEL);
		Level level = Level.toLevel(putlevel, logger.getLevel());
		logger.setLevel(level);

		LoggerResource loggerResource = new LoggerResource();
		loggerResource.setBaseLocation(baseLocation);
		loggerResource.setName(logger.getName());
		loggerResource.setLevel(logger.getLevel());
		loggerResource.setEffectiveLevel(logger.getEffectiveLevel());

		JSONObject result = loggerResource.toJSON();
		OrionServlet.writeJSONResponse(request, response, result);
		response.setHeader(ProtocolConstants.HEADER_LOCATION,
				result.getString(ProtocolConstants.KEY_LOCATION));
		return true;

	} catch (Exception e) {
		return statusHandler.handleRequest(request, response,
				new ServerStatus(IStatus.ERROR,
						HttpServletResponse.SC_BAD_REQUEST, e.getMessage(),
						e));
	}
}
 

public static NulsLogger getLogger(String fileName,int chainId) {
    Level level = StringUtils.isNotBlank(System.getProperty("log.level")) ? Level.toLevel(System.getProperty("log.level")) : DEFAULT_LEVEL;
    return getLogger("chain_"+chainId+ "_" +fileName, level, level);
}
 

public static NulsLogger getLogger(String fileName) {
    Level level = StringUtils.isNotBlank(System.getProperty("log.level")) ? Level.toLevel(System.getProperty("log.level")) : DEFAULT_LEVEL;
    return getLogger(fileName, level, level);
}
 

@Override
public Level convert(String value) {
    return Level.toLevel(value, Level.INFO);
}