Ejemplo n.º 1
0
 /**
  * Set Level. Ignore OFF - and higher then FINE
  *
  * @see java.util.logging.Handler#setLevel(java.util.logging.Level)
  * @param newLevel ignored
  * @throws java.lang.SecurityException
  */
 public synchronized void setLevel(Level newLevel) throws SecurityException {
   if (newLevel == null) return;
   if (newLevel == Level.OFF) super.setLevel(Level.SEVERE);
   else if (newLevel == Level.ALL || newLevel == Level.FINEST || newLevel == Level.FINER)
     super.setLevel(Level.FINE);
   else super.setLevel(newLevel);
 } //	SetLevel
Ejemplo n.º 2
0
  /**
   * Set up a pair of Handlers for jOVAL system logging events, one logging to the specified logFile
   * and the other to the console, at the indicated logging level, and return a Logger configured to
   * use them.
   */
  public static Logger createDuplex(File logFile, Level level) throws IOException {
    Handler logfileHandler = new FileHandler(logFile.getPath(), false);
    logfileHandler.setFormatter(new LogFormatter(Type.FILE));
    logfileHandler.setLevel(level);

    Handler consoleHandler = new ConsoleHandler();
    consoleHandler.setFormatter(new LogFormatter(Type.CONSOLE));
    consoleHandler.setLevel(level);

    Logger logger = Logger.getLogger(JOVALMsg.getLogger().getName());
    logger.setLevel(level);
    logger.addHandler(logfileHandler);
    logger.addHandler(consoleHandler);
    return logger;
  }
Ejemplo n.º 3
0
  private static void setLevel(final Level level) {

    LOGGER.setLevel(level);
    for (final Handler each : LOGGER.getHandlers()) {
      each.setLevel(level);
    }
  }
Ejemplo n.º 4
0
  private void setupLogging() throws IOException {
    System.out.println("Setting up logging...");
    Level level = LogHelper.getLogLevel(m_testData.getLogLevel());
    if (level == null) {
      System.err.println("No such log level and will use Level.INFO instead");
      level = Level.INFO;
    }
    fh = new FileHandler(m_testData.getLogFile(), false);
    // have to change the log level of the handler to let log come out as designed
    fh.setLevel(level);

    // change the formatter from default xml to simple text
    fh.setFormatter(new SimpleFormatter());
    theLogger.setLevel(level);
    theLogger.addHandler(fh);

    // close the Console handler so that we only need log in file
    Handler[] handlers = Logger.getLogger("").getHandlers();
    for (Handler handler : handlers) {
      if (handler instanceof ConsoleHandler) {
        handler.setLevel(Level.OFF);
        break;
      }
    }
  }
  protected static void setupSidlogger(Level lvl) {
    if (!Level.OFF.equals(lvl)) {
      Filter bslf = new BoshSidLoggerFilter();

      Logger BoshConnectionManagerLogger = Logger.getLogger(BoshConnectionManager.class.getName());
      Logger BoshSessionLogger = Logger.getLogger(BoshSession.class.getName());

      if (BoshConnectionManagerLogger.getLevel() == null
          || BoshSessionLogger.getLevel() == null
          || BoshConnectionManagerLogger.getLevel().intValue() < lvl.intValue()) {
        BoshConnectionManagerLogger.setLevel(lvl);
        BoshConnectionManagerLogger.setFilter(bslf);
        BoshSessionLogger.setLevel(lvl);
        BoshSessionLogger.setFilter(bslf);

        BoshConnectionManagerLogger.getParent().setFilter(bslf);
      }

      try {
        if (null == sidFilehandler) {
          sidFilehandler = new FileHandler("logs/bosh_sid.log", 10000000, 5, false);
          sidFilehandler.setLevel(lvl);
          sidFilehandler.setFilter(bslf);
          BoshConnectionManagerLogger.getParent().addHandler(sidFilehandler);
        }
      } catch (IOException ex) {
        log.log(Level.CONFIG, "Error creating BOSH SID logger" + ex);
      }
    }
  }
Ejemplo n.º 6
0
 @Override
 public void setLevelOfAllHandler(final Level newLevel) throws SecurityException {
   final Handler[] hs = getHandlers();
   for (final Handler h : hs) {
     h.setLevel(newLevel);
   }
 }
Ejemplo n.º 7
0
 /////////////////////////  non-public below  //////////////////////////////
 static synchronized void setConsoleLevel(Level level) {
   for (Handler h : logger.getHandlers()) {
     if (ConsoleHandler.class.isAssignableFrom(h.getClass())) {
       h.setLevel(level);
     }
   }
 }
 public void setLevel(Level level) {
   LogService.getRoot().setLevel(level);
   handler.setLevel(level);
   ParameterService.setParameterValue(
       MainFrame.PROPERTY_RAPIDMINER_GUI_LOG_LEVEL, level.getName());
   ParameterService.saveParameters();
 }
Ejemplo n.º 9
0
  private static void setBenchmarkConfiguration(int udp_sender, int udp_receiver, boolean verbose) {

    if (verbose) {
      Logger.getLogger(Logger.GLOBAL_LOGGER_NAME).setLevel(Level.ALL);
      for (Handler h : Logger.getLogger("").getHandlers()) h.setLevel(Level.ALL);
      Logger.getLogger(UDPConnector.class.toString()).setLevel(Level.ALL);

    } else {
      Logger.getLogger(Logger.GLOBAL_LOGGER_NAME).setLevel(Level.SEVERE);
      Logger.getLogger("").setLevel(Level.SEVERE);
    }

    // Network configuration optimal for performance benchmarks
    NetworkConfig.createStandardWithoutFile()
        // Disable deduplication OR strongly reduce lifetime
        .setString(NetworkConfigDefaults.DEDUPLICATOR, NetworkConfigDefaults.NO_DEDUPLICATOR)
        .setInt(NetworkConfigDefaults.EXCHANGE_LIFECYCLE, 1500)
        .setInt(NetworkConfigDefaults.MARK_AND_SWEEP_INTERVAL, 2000)

        // Increase buffer for network interface to 10 MB
        .setInt(NetworkConfigDefaults.UDP_CONNECTOR_RECEIVE_BUFFER, 10 * 1024 * 1024)
        .setInt(NetworkConfigDefaults.UDP_CONNECTOR_SEND_BUFFER, 10 * 1024 * 1024)

        // Increase threads for receiving and sending packets through the socket
        .setInt(NetworkConfigDefaults.UDP_CONNECTOR_RECEIVER_THREAD_COUNT, udp_receiver)
        .setInt(NetworkConfigDefaults.UDP_CONNECTOR_SENDER_THREAD_COUNT, udp_sender)

        // Disable message logging
        .setBoolean(NetworkConfigDefaults.UDP_CONNECTOR_LOG_PACKETS, verbose);
  }
Ejemplo n.º 10
0
 @Before
 public void setUp() {
   // 设置logger
   Logger logger = Logger.getLogger("wyq.toolbox.di");
   Handler h = new ConsoleHandler();
   h.setLevel(Level.ALL);
   logger.addHandler(h);
   logger.setLevel(Level.FINE); // set FINER to see tracing logs
 }
Ejemplo n.º 11
0
  private static void configureLogging() {
    final Handler[] handlers = Logger.getLogger("").getHandlers();
    for (final Handler handler : handlers) {
      handler.setLevel(Level.ALL);
    }

    Engine.getLogger().setLevel(Level.ALL);
    YahooParser.logger.setLevel(Level.ALL);
  }
Ejemplo n.º 12
0
  /** Initialize */
  private void initialize() {
    //	System.out.println("CLogConsole.initialize");

    //	Formatting
    setFormatter(CLogFormatter.get());
    //	Default Level
    super.setLevel(Level.INFO);
    //	Filter
    setFilter(CLogFilter.get());
  } //	initialize
Ejemplo n.º 13
0
 /**
  * Overidden to ensure changes to the Level for this logger are forwarded to the ErosHandler.
  *
  * @param newLevel The new logging level.
  * @throws SecurityException
  * @see Logger#setLevel(Level)
  */
 public void setLevel(Level newLevel) throws SecurityException {
   super.setLevel(newLevel);
   Handler[] handlers = this.getHandlers();
   for (int i = 0; i < handlers.length; i++) {
     Handler handler = handlers[i];
     if (handler instanceof ErosHandler) {
       handler.setLevel(newLevel);
     }
   }
 }
Ejemplo n.º 14
0
  /**
   * Sets the level of all muCommander loggers, namely {@link AppLogger}, {@link FileLogger} and
   * {@link CommonsLogger}.
   *
   * @param level the new log level
   */
  public static void updateLogLevel(Level level) {
    // Set the level of muCommander loggers.
    // Note: non-muCommander loggers default to the level defined in the JRE's logging.properties.
    CommonsLogger.getLogger().setLevel(level);
    FileLogger.getLogger().setLevel(level);
    AppLogger.getLogger().setLevel(level);

    Logger rootLogger = LogManager.getLogManager().getLogger("");
    Handler handlers[] = rootLogger.getHandlers();
    for (Handler handler : handlers) handler.setLevel(level);
  }
Ejemplo n.º 15
0
 protected static void setFileHandlerLevel(Handler handler, Level newLevel) {
   if (handler instanceof FileHandler) {
     handler.setLevel(newLevel);
   } else if (handler instanceof CompositeHandler) {
     setFileHandlerLevel(((CompositeHandler) handler).getHandlers(), newLevel);
   } else if (handler instanceof DelegatingHandler) {
     setFileHandlerLevel(((DelegatingHandler) handler).getBaseHandler(), newLevel);
   } else {
     //
   }
 }
Ejemplo n.º 16
0
 static {
   if ((System.getProperty("java.util.logging.config.file") == null)
       && (System.getProperty("java.util.logging.config.class") == null)) {
     LOGGER.setUseParentHandlers(false);
     final Handler handler = new ConsoleHandler();
     handler.setFormatter(new PlainFormatter());
     addOrSetHandler(handler);
     LOGGER.setLevel(Level.INFO);
     handler.setLevel(Level.ALL);
   }
 }
Ejemplo n.º 17
0
 static {
   HANDLER =
       new StreamHandler(
           System.out,
           new Formatter() {
             public String format(LogRecord record) {
               return String.format(
                   "[Guice %s] %s%n", record.getLevel().getName(), record.getMessage());
             }
           });
   HANDLER.setLevel(Level.ALL);
 }
Ejemplo n.º 18
0
 private static void setVlog(Logger logger, LogLevel logLevel) {
   final Level newLevel = logLevel.getLevel();
   logger.setLevel(newLevel);
   do {
     for (Handler handler : logger.getHandlers()) {
       Level handlerLevel = handler.getLevel();
       if (newLevel.intValue() < handlerLevel.intValue()) {
         handler.setLevel(newLevel);
       }
     }
   } while (logger.getUseParentHandlers() && (logger = logger.getParent()) != null);
 }
  public Handler addLogConsoleHandler(Level l) {
    if (l == null) {
      return addLogConsoleHandler(Level.ALL);
    }
    // Create and set handler
    Handler systemOut = new ConsoleHandler();
    systemOut.setLevel(l);
    getLogger().addHandler(systemOut);
    getLogger().setLevel(l);

    // Prevent logs from processed by default Console handler.
    getLogger().setUseParentHandlers(false); // Solution 1
    return systemOut;
  }
Ejemplo n.º 20
0
  /**
   * Initialization of the task.
   *
   * @throws BuildException in case an error occured
   */
  @Override
  public void init() throws BuildException {
    Logger baselogger = Logger.getLogger("org.cesta");
    baselogger.setLevel(Level.ALL);

    // we want to disable other handlers and pass everything to Ant
    for (Handler h : baselogger.getHandlers()) baselogger.removeHandler(h);

    // create TaskLogHandler, which forwards all messages to Ant logging subsystem
    Handler handler = new TaskLogHandler(this);
    handler.setFormatter(new TaskLogFormatter());
    handler.setLevel(Level.ALL);
    baselogger.addHandler(handler);
  }
Ejemplo n.º 21
0
 void initialize() {
   // set this as a top level logger, to control console level
   logger = Logger.getLogger("com.jaivox.util.Log");
   logger.setUseParentHandlers(false);
   Handler hConsole = new ConsoleHandler();
   hConsole.setFormatter(new Logformat());
   hConsole.setLevel(Level.FINEST);
   logger.addHandler(hConsole);
   logger.setLevel(Level.FINEST);
   // what is the level of this logger?
   String s = logger.getLevel().toString();
   System.out.println("Logger log level after creating " + s);
   initialized = true;
 }
Ejemplo n.º 22
0
  private static void configureLogging(CommandLineOptionHelper helper) {
    Level logLevel =
        helper.isParamPresent("-debug") ? Level.FINE : LoggingOptions.getDefaultLogLevel();
    if (logLevel == null) {
      logLevel = Level.INFO;
    }
    Logger.getLogger("").setLevel(logLevel);
    Logger.getLogger("org.openqa.jetty").setLevel(Level.WARNING);

    String logFilename =
        helper.isParamPresent("-log")
            ? helper.getParamValue("-log")
            : LoggingOptions.getDefaultLogOutFile();
    if (logFilename != null) {
      for (Handler handler : Logger.getLogger("").getHandlers()) {
        if (handler instanceof ConsoleHandler) {
          Logger.getLogger("").removeHandler(handler);
        }
      }
      try {
        Handler logFile = new FileHandler(new File(logFilename).getAbsolutePath(), true);
        logFile.setFormatter(new TerseFormatter(true));
        logFile.setLevel(logLevel);
        Logger.getLogger("").addHandler(logFile);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    } else {
      boolean logLongForm = helper.isParamPresent("-logLongForm");
      for (Handler handler : Logger.getLogger("").getHandlers()) {
        if (handler instanceof ConsoleHandler) {
          handler.setLevel(logLevel);
          handler.setFormatter(new TerseFormatter(logLongForm));
        }
      }
    }
  }
Ejemplo n.º 23
0
  static {
    try {
      final Level level = Level.parse(System.getProperty(getLoggerName(), "WARNING"));

      final Handler[] handlers = Logger.getLogger("").getHandlers();
      for (final Handler handler : handlers) {
        handler.setLevel(level);
      }

      logger.setLevel(level);
    } catch (final Exception e) {
      System.out.println("Exception " + e + " in Aparapi logging setup");
      e.printStackTrace();
    }
  };
Ejemplo n.º 24
0
  /**
   * Sets the application-wide log level.
   *
   * @param logLevel Log level to set
   */
  public static void setApplicationLogLevel(final Level logLevel) {
    final LogManager logManager = LogManager.getLogManager();
    final List<String> loggerNames = Collections.list(logManager.getLoggerNames());
    for (final String loggerName : loggerNames) {
      final Logger logger = logManager.getLogger(loggerName);
      if (logger != null) {
        logger.setLevel(null);
        for (final Handler handler : logger.getHandlers()) {
          handler.setLevel(logLevel);
        }
      }
    }

    final Logger rootLogger = Logger.getLogger("");
    rootLogger.setLevel(logLevel);
  }
Ejemplo n.º 25
0
 private static void setConsoleHandler(Logger logger, boolean removeOtherHandlers) {
   Handler consoleHandler = null;
   for (Handler h : logger.getHandlers()) {
     if (h instanceof ConsoleHandler) {
       consoleHandler = h;
     } else if (removeOtherHandlers) {
       logger.removeHandler(h);
     }
   }
   if (consoleHandler == null) {
     consoleHandler = new ConsoleHandler();
     logger.addHandler(new ConsoleHandler());
   }
   consoleHandler.setLevel(Level.ALL);
   consoleHandler.setFilter(null);
 }
Ejemplo n.º 26
0
  public static void setGlobalLogLevel(Level targetLogLevel) {
    for (Enumeration<String> loggerNames = LogManager.getLogManager().getLoggerNames();
        loggerNames.hasMoreElements(); ) {
      String loggerName = loggerNames.nextElement();
      Logger logger = LogManager.getLogManager().getLogger(loggerName);

      if (logger != null) {
        logger.setLevel(targetLogLevel);
      }
    }

    for (Handler handler : Logger.getLogger("").getHandlers()) {
      handler.setLevel(targetLogLevel);
    }

    Logger.getLogger("").setLevel(targetLogLevel);
  }
Ejemplo n.º 27
0
 /**
  * Force logger to a new level.
  *
  * @param level TRACE,DEBUG,INFO,WARN,ERROR,FATAL
  */
 public static void setUp(String level) {
   if (forceJuli || log4j == null) {
     Logger.juli.setLevel(toJuliLevel(level));
   } else {
     Logger.log4j.setLevel(org.apache.log4j.Level.toLevel(level));
     if (redirectJuli) {
       java.util.logging.Logger rootLogger = java.util.logging.Logger.getLogger("");
       for (Handler handler : rootLogger.getHandlers()) {
         rootLogger.removeHandler(handler);
       }
       Handler activeHandler = new JuliToLog4jHandler();
       java.util.logging.Level juliLevel = toJuliLevel(level);
       activeHandler.setLevel(juliLevel);
       rootLogger.addHandler(activeHandler);
       rootLogger.setLevel(juliLevel);
     }
   }
 }
Ejemplo n.º 28
0
 public static synchronized LocalOnlyAcsLogger getInstance(String namespace, Level level) {
   if (instance == null) {
     LogConfig testLogConfig = new LogConfig();
     testLogConfig.setDefaultMinLogLevelLocal(AcsLogLevel.getNativeLevel(level).getAcsLevel());
     instance = new LocalOnlyAcsLogger(namespace, testLogConfig);
     instance.setUseParentHandlers(false);
     Handler logHandler = new StdOutConsoleHandler(testLogConfig, namespace, null);
     logHandler.setFormatter(
         new AcsXMLLogFormatter() {
           public String format(LogRecord lr) {
             String xml = super.format(lr);
             return xml + '\n';
           }
         });
     logHandler.setLevel(level);
     instance.addHandler(logHandler);
   }
   return instance;
 }
Ejemplo n.º 29
0
  /**
   * Set the logging level. The levels in descending order are:<br>
   *
   * <ul>
   *   <li>ALL
   *   <li>SEVERE (highest value)
   *   <li>WARNING
   *   <li>INFO
   *   <li>CONFIG
   *   <li>FINE
   *   <li>FINER
   *   <li>FINEST (lowest value)
   *   <li>OFF
   * </ul>
   *
   * @param logLevel one of the valid log levels according to {@link Level#parse(String)}
   */
  public static void setLogLevel(String logLevel) {
    Level level;

    try {
      level = Level.parse(logLevel.toUpperCase());
    } catch (IllegalArgumentException e) {
      LOG.warning(
          () ->
              "Invalid log level %s. Must be one of OFF, SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST or ALL.");
      return;
    }

    Logger root = Logger.getLogger(Main.class.getPackage().getName());
    root.setLevel(level);

    for (Handler handler : root.getHandlers()) {
      handler.setLevel(level);
    }
  }
Ejemplo n.º 30
0
 @Override
 public synchronized void start(final StartContext context) throws StartException {
   final Handler handler;
   final ModuleLoader moduleLoader = Module.forClass(CustomHandlerService.class).getModuleLoader();
   final ModuleIdentifier id = ModuleIdentifier.create(moduleName);
   try {
     final Class<?> handlerClass =
         Class.forName(className, false, moduleLoader.loadModule(id).getClassLoader());
     if (Handler.class.isAssignableFrom(handlerClass)) {
       handler = (Handler) handlerClass.newInstance();
     } else {
       throw new StartException(
           String.format(
               "%s %s is not a valid %s.", CUSTOM_HANDLER, className, Handler.class.getName()));
     }
   } catch (ClassNotFoundException e) {
     throw new StartException(e);
   } catch (ModuleLoadException e) {
     throw new StartException(
         String.format(
             "%s %s is not a valid %s.", CUSTOM_HANDLER, className, Handler.class.getName()),
         e);
   } catch (InstantiationException e) {
     throw new StartException(
         String.format(
             "%s %s is not a valid %s.", CUSTOM_HANDLER, className, Handler.class.getName()),
         e);
   } catch (IllegalAccessException e) {
     throw new StartException(
         String.format(
             "%s %s is not a valid %s.", CUSTOM_HANDLER, className, Handler.class.getName()),
         e);
   }
   formatterSpec.apply(handler);
   if (level != null) handler.setLevel(level);
   try {
     handler.setEncoding(encoding);
   } catch (UnsupportedEncodingException e) {
     throw new StartException(e);
   }
   value = handler;
 }