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

@Test
public void shouldLogExceptionStacktrace() throws IOException {
  Logger logger = Logger.getLogger(ProcessScope.class.getName());
  try (ByteArrayOutputStream out = new ByteArrayOutputStream();) {
    Handler handler = new StreamHandler(out, new SimpleFormatter());
    logger.addHandler(handler);
    try {
      ProcessScope scope = new ProcessScope();
      Object variable = scope.get("testObject", null);
      assertNull(variable);
    } finally {
      handler.flush();
      handler.close();
      logger.removeHandler(handler);
    }
    // test for logged exception
    String message = new String(out.toByteArray(), StandardCharsets.UTF_8);
    assertTrue(!message.isEmpty());
    assertTrue(message.contains("org.camunda.bpm.engine.spring.components.scope.ProcessScope get"));
    assertTrue(message.contains("couldn't return value from process scope! java.lang.NullPointerException"));
    assertTrue(message.contains("at org.camunda.bpm.engine.spring.components.scope.ProcessScope.getExecutionId(ProcessScope.java:")); 
    assertTrue(message.contains("at org.camunda.bpm.engine.spring.components.scope.ProcessScope.getConversationId(ProcessScope.java:")); 
    assertTrue(message.contains("at org.camunda.bpm.engine.spring.components.scope.ProcessScope.get(ProcessScope.java:")); 
    assertTrue(message.contains("at org.camunda.bpm.engine.spring.test.components.scope.ProcessScopeTest.shouldLogExceptionStacktrace(ProcessScopeTest.java:")); 
  }
}
 

/** Allows tests to flush all standard handlers */
static void flush(boolean clear) {
    System.err.flush();


    Handler s = streamHandler;
    if (s != null) {
        s.flush();
    }

    Handler d = defaultHandler;
    if (d != null) {
        d.flush();
    }

    if (clear) {
        streamHandler = null;
        defaultHandler = null;
    }
}
 

/**
 * Test PayaraException with no parameters specified throwing
 * and logging.
 */
@Test
public void testPayaraExceptionWithNothing() {
    // this message must match PayaraIdeException() constructor
    // log message.
    String gfieMsg = "Caught PayaraIdeException.";
    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();
    } 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);
}
 

/**
 * 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);
}
 

/**
 * Test GlassFishException with no parameters specified throwing
 * and logging.
 */
@Test
public void testGlassFishExceptionWithNothing() {
    // this message must match GlassFishIdeException() constructor
    // log message.
    String gfieMsg = "Caught GlassFishIdeException.";
    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();
    } 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);
}
 

/**
 * 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);
}
 

/**
 * 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);
}
 

private void flushAndRemoveLogHandler(Logger rootLogger, Handler handler) {
  if (handler != null) {
    handler.flush();
  }
  if (rootLogger != null && handler != null) {
    rootLogger.removeHandler(handler);
  }
}
 

public static void flushLogs() {
  Logger rootLogger = LogManager.getLogManager().getLogger("");
  if (rootLogger == null) {
    return;
  }
  Handler[] handlers = rootLogger.getHandlers();
  if (handlers == null) {
    return;
  }
  for (Handler h : handlers) {
    h.flush();
  }
}
 

public void flush( )
{
	if ( fileHandlers != null )
	{
		for ( Handler handler : fileHandlers )
		{
			handler.flush();
		}
	}
}
 

/** Flushes all loggers at com.google.devtools.build.* or higher. */
public static void flushServerLog() {
  for (Logger logger = templateLogger; logger != null; logger = logger.getParent()) {
    for (Handler handler : logger.getHandlers()) {
      if (handler != null) {
        handler.flush();
      }
    }
  }
}
 

/**
 *
 */
public static void flushSessionLog() {
    Handler[] handlers = Constants.zknlogger.getHandlers();
    for (Handler h : handlers) {
        if (h.toString().contains("StreamHandler")) {
            h.flush();
        }
    }
}
 

/**
 * Flush the handler.
 */
public void flush()
{
  int level = getLevel().intValue();
  
  for (int i = 0; i < _handlers.length; i++) {
    Handler handler = _handlers[i];

    if (level <= handler.getLevel().intValue())
      handler.flush();
  }
}
 

/**
 * Flushes the data.
 *
 * @return the result of the operation
 */
@Override
public ResultCode flush() {
  ResultCode resultCode = ResultCode.SUCCESS;
  for (Handler handler : logger.getHandlers()) {
    try {
      handler.flush();
    } catch (Throwable t) {
      resultCode = ResultCode.FAILURE;
    }
  }
  return resultCode;
}
 

/**
 * 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);
}
 

protected void flush(Logger log) {
    ApiProxy.flushLogs();
    for (Handler handler : log.getHandlers()) {
        handler.flush();
    }
}
 

@Override
public void flush() {
    for (Handler h : Lookup.getDefault().lookupAll(Handler.class)) {
        h.flush();
    }
}
 

@Override
public void flush() {
    for (Handler h : instances) {
        h.flush();
    }
}
 

@Override
public void close() {
  for (Handler h : LOG.getHandlers()) {
    h.flush();
  }
}
 

private static void publishAndFlush(Handler handler, LogRecord logRecord) {
  handler.publish(logRecord);
  handler.flush();
}