Java Code Examples for java.util.logging.Handler#close()

/**
 * Test GlassFishException with message throwing and logging.
 */
@Test
public void testGlassFishExceptionWithMsg() {
    String gfieMsg = "Test exception";
    java.util.logging.Logger logger = Logger.getLogger();
    Level logLevel = logger.getLevel();
    OutputStream logOut = new ByteArrayOutputStream(256);
    Handler handler = new StreamHandler(logOut, new SimpleFormatter());
    handler.setLevel(Level.WARNING);
    logger.addHandler(handler);       
    logger.setLevel(Level.WARNING);
    try {
        throw new GlassFishIdeException(gfieMsg);
    } catch (GlassFishIdeException gfie) {
        handler.flush();
    } finally {
        logger.removeHandler(handler);
        handler.close();
        logger.setLevel(logLevel);
    }
    String logMsg = logOut.toString();
    int contains = logMsg.indexOf(gfieMsg);
    assertTrue(contains > -1);
}
 

private void handleException(Thread thread, Throwable exception) {
  LOG.severe("Local Mode Process exiting.");
  LOG.log(Level.SEVERE,
      "Exception caught in thread: " + thread.getName() + " with id: " + thread.getId(),
      exception);
  for (Handler handler : java.util.logging.Logger.getLogger("").getHandlers()) {
    handler.close();
  }

  // Attempts to shutdown all the thread in threadsPool. This will send Interrupt to every
  // thread in the pool. Threads may implement a clean Interrupt logic.
  threadsPool.shutdownNow();

  // not owned by HeronInstance). To be safe, not sending these interrupts.
  Runtime.getRuntime().halt(1);
}
 

public void stop() {
  synchronized (this) {
    LOG.severe("Instance Process exiting.\n");
    for (Handler handler : java.util.logging.Logger.getLogger("").getHandlers()) {
      handler.close();
    }

    // Attempts to shutdown all the thread in threadsPool. This will send Interrupt to every
    // thread in the pool. Threads may implement a clean Interrupt logic.
    threadsPool.shutdownNow();

    // TODO : It is not clear if this signal should be sent to all the threads (including threads
    // not owned by HeronInstance). To be safe, not sending these interrupts.
    Runtime.getRuntime().halt(1);
  }
}
 

@Override
protected OperationStepHandler additionalModelStep(final LogContextConfiguration logContextConfiguration) {
    return new OperationStepHandler() {
        @Override
        public void execute(final OperationContext context, final ModelNode operation) throws OperationFailedException {
            // If we don't require runtime steps to be executed we need to discard records on the delayed handler
            if (!requiresRuntime(context)) {
                HandlerConfiguration configuration = logContextConfiguration.getHandlerConfiguration(context.getCurrentAddressValue());
                if (configuration != null) {
                    if (!(configuration.getInstance() instanceof DelayedHandler)) {
                        throw LoggingLogger.ROOT_LOGGER.invalidType(DelayedHandler.class, configuration.getInstance().getClass());
                    }
                    final DelayedHandler delayedHandler = (DelayedHandler) configuration.getInstance();
                    // Clear any previous handlers and close them, then add the new handler
                    final Handler[] current = delayedHandler.setHandlers(new Handler[] {new DiscardingHandler()});
                    if (current != null) {
                        for (Handler handler : current) {
                            handler.close();
                        }
                    }
                }
            }
        }
    };
}
 

/**
 * 初始化全局Logger
 *
 * @return
 */
private static void initGlobalLog(String logPath) {
    // 获取Log
    Logger log = Logger.getLogger(LOG_NAME);
    // 为log设置全局等级
    log.setLevel(Level.ALL);
    Handler[] hs = log.getHandlers();
    for (Handler h : hs) {
        h.close();
        log.removeHandler(h);
    }
    // 添加控制台handler
    //LogUtil.addConsoleHandler(log, Level.INFO);
    // 添加文件输出handler
    LogUtil.addFileHandler(log, Level.INFO, logPath);
    // 设置不适用父类的handlers，这样不会在控制台重复输出信息
    log.setUseParentHandlers(false);
    globalLog = log;
}
 

/**
 * Test PayaraException with message throwing and logging.
 */
@Test
public void testPayaraExceptionWithMsg() {
    String gfieMsg = "Test exception";
    java.util.logging.Logger logger = Logger.getLogger();
    Level logLevel = logger.getLevel();
    OutputStream logOut = new ByteArrayOutputStream(256);
    Handler handler = new StreamHandler(logOut, new SimpleFormatter());
    handler.setLevel(Level.WARNING);
    logger.addHandler(handler);       
    logger.setLevel(Level.WARNING);
    try {
        throw new PayaraIdeException(gfieMsg);
    } catch (PayaraIdeException gfie) {
        handler.flush();
    } finally {
        logger.removeHandler(handler);
        handler.close();
        logger.setLevel(logLevel);
    }
    String logMsg = logOut.toString();
    int contains = logMsg.indexOf(gfieMsg);
    assertTrue(contains > -1);
}
 

public static void printStopTime(String name) {
    final long stopTimeNanoSeconds = System.nanoTime() - bootStopTime;
    final Logger logger = Logger.getLogger("io.quarkus");
    final BigDecimal secondsRepresentation = convertToBigDecimalSeconds(stopTimeNanoSeconds);
    logger.infof("%s stopped in %ss",
            (UNSET_VALUE.equals(name) || name == null || name.trim().isEmpty()) ? "Quarkus" : name,
            secondsRepresentation);
    bootStopTime = -1;

    /**
     * We can safely close log handlers after stop time has been printed.
     */
    Handler[] handlers = InitialConfigurator.DELAYED_HANDLER.clearHandlers();
    for (Handler handler : handlers) {
        try {
            handler.close();
        } catch (Throwable ignored) {
        }
    }
}
 

/**
 * Removed all the handlers of the given {@link Logger} instance.
 *
 * @param logger {@link Logger} to be cleaned up.
 */
private static void cleanupLogger(Logger logger) {
  if (logger != null) {
    Handler[] handlers = logger.getHandlers();
    for (Handler handler : handlers) {
      handler.close();
      logger.removeHandler(handler);
    }
  }
}
 

@Override
public void onDisable() {
    try {
        core.stop();
    } catch (ServerListPlusException ignored) {}
    getLogger().info(getDisplayName() + " disabled.");
    // BungeeCord closes the log handlers automatically, but Bukkit does not
    for (Handler handler : getLogger().getHandlers())
        handler.close();
}
 

/**
 * Test PayaraException with message and cause <code>Throwable</code>
 * throwing and logging.
 */
@Test
public void testPayaraExceptionWithMsgAndCause() {
    String gfieMsg = "Test exception";
    String causeMsg = "Cause exception";
    java.util.logging.Logger logger = Logger.getLogger();
    Level logLevel = logger.getLevel();
    OutputStream logOut = new ByteArrayOutputStream(256);
    Handler handler = new StreamHandler(logOut, new SimpleFormatter());
    handler.setLevel(Level.WARNING);
    logger.addHandler(handler);       
    logger.setLevel(Level.WARNING);
    try {
        try {
            throw new Exception(causeMsg);
        } catch (Exception e) {
            throw new PayaraIdeException(gfieMsg, e);
        }
    } catch (PayaraIdeException gfie) {
        handler.flush();
    } finally {
        logger.removeHandler(handler);
        handler.close();
        logger.setLevel(logLevel);
    }
    String logMsg = logOut.toString();
    int containsGfieMsg = logMsg.indexOf(gfieMsg);
    int containsCauseMsg = logMsg.indexOf(causeMsg);
    assertTrue(containsGfieMsg > -1 && containsCauseMsg > -1);
}
 

private static void clearLogContext() {
    // Remove the configurator and clear the log context
    final Configurator configurator = EMBEDDED_LOG_CONTEXT.getLogger("").detach(Configurator.ATTACHMENT_KEY);
    // If this was a PropertyConfigurator we can use the LogContextConfiguration API to tear down the LogContext
    if (configurator instanceof PropertyConfigurator) {
        final LogContextConfiguration logContextConfiguration = ((PropertyConfigurator) configurator).getLogContextConfiguration();
        clearLogContext(logContextConfiguration);
    } else if (configurator instanceof LogContextConfiguration) {
        clearLogContext((LogContextConfiguration) configurator);
    } else {
        // Remove all the handlers and close them as well as reset the loggers
        final List<String> loggerNames = Collections.list(EMBEDDED_LOG_CONTEXT.getLoggerNames());
        for (String name : loggerNames) {
            final Logger logger = EMBEDDED_LOG_CONTEXT.getLoggerIfExists(name);
            if (logger != null) {
                final Handler[] handlers = logger.clearHandlers();
                if (handlers != null) {
                    for (Handler handler : handlers) {
                        handler.close();
                    }
                }
                logger.setFilter(null);
                logger.setUseParentFilters(false);
                logger.setUseParentHandlers(true);
                logger.setLevel(Level.INFO);
            }
        }
    }
}
 

/**
 * Test GlassFishException with message and cause <code>Throwable</code>
 * throwing and logging.
 */
@Test
public void testGlassFishExceptionWithMsgAndCause() {
    String gfieMsg = "Test exception";
    String causeMsg = "Cause exception";
    java.util.logging.Logger logger = Logger.getLogger();
    Level logLevel = logger.getLevel();
    OutputStream logOut = new ByteArrayOutputStream(256);
    Handler handler = new StreamHandler(logOut, new SimpleFormatter());
    handler.setLevel(Level.WARNING);
    logger.addHandler(handler);       
    logger.setLevel(Level.WARNING);
    try {
        try {
            throw new Exception(causeMsg);
        } catch (Exception e) {
            throw new GlassFishIdeException(gfieMsg, e);
        }
    } catch (GlassFishIdeException gfie) {
        handler.flush();
    } finally {
        logger.removeHandler(handler);
        handler.close();
        logger.setLevel(logLevel);
    }
    String logMsg = logOut.toString();
    int containsGfieMsg = logMsg.indexOf(gfieMsg);
    int containsCauseMsg = logMsg.indexOf(causeMsg);
    assertTrue(containsGfieMsg > -1 && containsCauseMsg > -1);
}
 

/** Does its best to close provided handler. Can close handlers created by
 * {@link #createDispatchHandler(java.util.logging.Handler, int)} as well.
 */
public static void close(Handler h) {
    if (h == null) {
        return;
    }
    if (h instanceof DispatchingHandler) {
        ((DispatchingHandler)h).doClose();
    } else {
        h.close();
    }
}
 

public static void closeLogFile() {
  for (Handler handler : LOG.getHandlers()) {
    if (handler instanceof FileHandler) {
      LOG.removeHandler(handler);
      handler.close();
    }
  }
}
 

private static void clearLogger() {
  final Logger log = logger;
  if (log != null) {
    logger = DEFAULT_LOGGER;
    for (Handler h : log.getHandlers()) {
      log.removeHandler(h);
      // try and close the handler ignoring any exceptions
      try {
        h.close();
      } catch (Exception ex) {
        // ignore
      }
    }
  }
}
 

/**
 * Finishes the process and cleans up everything, including GUI.
 *
 * @since 7.4
 */
private void finishProcess(Handler logHandler) {
	stop();
	tearDown();
	if (logHandler != null) {
		getLogger().removeHandler(logHandler);
		logHandler.close();
	}
	ActionStatisticsCollector.getInstance().logExecutionFinished(this);
}
 

public static void unregisterHandler(Handler handler) {
	if (handler == null) {
		return;
	}
	handler.close();
	Logger.getLogger("").removeHandler(handler);
}
 

@Override
public void close() throws SecurityException {
    for (Handler h : instances) {
        h.close();
    }
}
 

private static void removeLogHandler(Handler handler) {
    Logger.getLogger("").removeHandler(handler);
    handler.close();
}
 

private void handleException(Thread thread, Throwable exception) {
  // We would fail fast when errors occur
  if (exception instanceof Error) {
    LOG.log(Level.SEVERE,
        "Error caught in thread: " + thread.getName()
            + " with thread id: " + thread.getId() + ". Process halting...",
        exception);
    Runtime.getRuntime().halt(1);
  }

  // We would fail fast when exceptions happen in main thread
  if (thread.getId() == mainThreadId) {
    LOG.log(Level.SEVERE,
        "Exception caught in main thread. Process halting...",
        exception);
    Runtime.getRuntime().halt(1);
  }

  LOG.log(Level.SEVERE,
      "Exception caught in thread: " + thread.getName()
          + " with thread id: " + thread.getId(),
      exception);

  String sinkId = null;
  Integer thisSinkRetryAttempts = 0;

  // We enforced the name of thread running particular IMetricsSink equal to its sink-id
  // If the thread name is a key of SinkExecutors, then it is a thread running IMetricsSink
  if (sinkExecutors.containsKey(thread.getName())) {
    sinkId = thread.getName();
    // Remove the unneeded Communicator bind with Metrics Manager Server
    metricsManagerServer.removeSinkCommunicator(sinkId);

    // Remove the old sink executor and close the sink
    SinkExecutor oldSinkExecutor = sinkExecutors.remove(sinkId);
    SysUtils.closeIgnoringExceptions(oldSinkExecutor);

    thisSinkRetryAttempts = sinksRetryAttempts.remove(sinkId);
  }

  if (sinkId != null && thisSinkRetryAttempts != 0) {
    LOG.info(String.format("Restarting IMetricsSink: %s with %d available retries",
        sinkId, thisSinkRetryAttempts));

    // That means it was a sinkExecutor throwing exceptions and threadName is sinkId
    SinkExecutor newSinkExecutor = initSinkExecutor(sinkId);

    // Update the SinkExecutor in sinkExecutors
    sinkExecutors.put(sinkId, newSinkExecutor);

    // Update the retry attempts if it is > 0
    if (thisSinkRetryAttempts > 0) {
      thisSinkRetryAttempts--;
    }
    sinksRetryAttempts.put(sinkId, thisSinkRetryAttempts);

    // Update the list of Communicator in Metrics Manager Server
    metricsManagerServer.addSinkCommunicator(sinkId, newSinkExecutor.getCommunicator());

    // Restart it
    executors.execute(newSinkExecutor);
  } else if (sinkId != null
      && thisSinkRetryAttempts == 0
      && sinkExecutors.size() > 0) {
    // If the dead executor is the only one executor and it is removed,
    // e.g. sinkExecutors.size() == 0, we would exit the process directly

    LOG.severe("Failed to recover from exceptions for IMetricsSink: " + sinkId);
    LOG.info(sinkId + " would close and keep running rest sinks: " + sinkExecutors.keySet());
  } else {
    // It is not recoverable (retried too many times, or not an exception from IMetricsSink)
    // So we would do basic cleaning and exit
    LOG.info("Failed to recover from exceptions; Metrics Manager Exiting");
    for (Handler handler : java.util.logging.Logger.getLogger("").getHandlers()) {
      handler.close();
    }
    // Attempts to shutdown all the thread in threadsPool. This will send Interrupt to every
    // thread in the pool. Threads may implement a clean Interrupt logic.
    executors.shutdownNow();

    // (including threads not owned by HeronInstance). To be safe, not sending these
    // interrupts.
    Runtime.getRuntime().halt(1);
  }
}