/** * Returns the current thread-local class loader * * @return the current thread-local class loader */ public ClassLoader getCurrentClassLoader() { final ClassLoader result = Thread.currentThread().getContextClassLoader(); // Attempt to provide more information to issue 604. if (result == null) { LOG.error(new Throwable(), "The CCL of current thread ''{0}'' is null", Thread.currentThread().getName()); } return result; } }
private ResultSet doQuery(final PreparedStatement stm) throws SQLException { LOG.ok("Execute query {0}", stm.toString()); return stm.executeQuery(); }
public static void logOpExit( Log opLog, ConnectorOperationalContext opContext, Class<?> opClass, String methodName) { if (!opLog.isLoggable(SpiOperationLoggingUtil.LOG_LEVEL)) { return; } StringBuilder sb = new StringBuilder(); appendInstanceName(sb, opContext); sb.append("Return"); opLog.log(opClass, methodName, SpiOperationLoggingUtil.LOG_LEVEL, sb.toString(), null); }
@Test public void checkBasicLogging() { for (Log.Level level : Log.Level.values()) { final String EXPECTED_MSG = "Message: " + level; MockLogSpi spi = new MockLogSpi(); spi._isloggable = true; Log log = Log.getLog(String.class, spi); if (Log.Level.ERROR.equals(level)) { log.error(EXPECTED_MSG); } else if (Log.Level.INFO.equals(level)) { log.info(EXPECTED_MSG); } else if (Log.Level.OK.equals(level)) { log.ok(EXPECTED_MSG); } else if (Log.Level.WARN.equals(level)) { log.warn(EXPECTED_MSG); } assertNull(spi._exception); assertTrue(spi._isloggable); assertEquals(spi._level, level); assertEquals(spi._class, String.class); assertEquals(spi._message, EXPECTED_MSG); } }
public static void dispose(final ConnectorPoolKey connectorPoolKey) { synchronized (POOLS) { ObjectPool<PoolableConnector> pool = POOLS.remove(connectorPoolKey); if (null != pool) { try { pool.shutdown(); } catch (Exception e) { LOG.warn(e, "Failed to close pool: {0}", pool); } } } }
public static boolean isLoggable() { return LOG.isLoggable(LOG_LEVEL); } }
public void warn(final Throwable ex, final String format, final Object... args) { log(Level.WARN, ex, format, args); }
@Test public void checkMessageLog() { final String METHOD = "checkMessageLog"; final String EXPECTED_MSG = "any old message will do"; // create log w/ Mock.. MockLogSpi spi = new MockLogSpi(); Log log = Log.getLog(String.class, spi); // try each of the is log methods.. // attempt to check the message methods... spi._message = null; spi._isloggable = false; log.error(EXPECTED_MSG); assertNull(spi._message); assertEquals(spi._class, String.class); spi._isloggable = true; log.error(EXPECTED_MSG); assertEquals(spi._level, Log.Level.ERROR); assertEquals(spi._message, EXPECTED_MSG); assertEquals(spi._class, String.class); assertEquals(spi._methodName, METHOD); }
@Test public void checkSystemProperty() { // don't mess up other tests w/ changing out logging.. synchronized (Log.class) { // save the original.. Class<?> orig = Log.getSpiClass(); try { // check the default.. Log.getLog(String.class); assertEquals(Log.getSpiClass(), StdOutLogger.class); // attempt to get the mock logger Log.setSpiClass(null); System.setProperty(Log.LOGSPI_PROP, MockLogSpi.class.getName()); Log.getLog(String.class); assertEquals(Log.getSpiClass(), MockLogSpi.class); // attempt to change it, so make sure its cached.. System.setProperty(Log.LOGSPI_PROP, StdOutLogger.class.getName()); assertEquals(Log.getSpiClass(), MockLogSpi.class); } finally { // restore logger to original state.. Log.setSpiClass(orig); System.clearProperty(Log.LOGSPI_PROP); } } }
final String EXPECTED = "some message: {0}"; MockLogSpi spi = new MockLogSpi(); Log log = Log.getLog(String.class, spi); log.log(Log.Level.INFO, new Exception(), EXPECTED, 1); assertEquals(spi._level, Log.Level.INFO); assertEquals(spi._class, String.class); log = Log.getLog(String.class, spi); spi._isloggable = true; final Exception EX = new Exception(); log.log(Log.Level.ERROR, EX, EXPECTED, 1); assertEquals(spi._message, "some message: 1"); assertEquals(spi._level, Log.Level.ERROR); log = Log.getLog(String.class, spi); spi._isloggable = true; final String EX_MSG = "dafdslfkj"; log.log(Log.Level.ERROR, new Exception(EX_MSG), null); assertEquals(spi._level, Log.Level.ERROR); assertEquals(spi._class, String.class);
/** * Get the logger for the particular class. <code> * private static final Log LOG = Log.getLog(MyClass.class); * </code> * * @param clazz * class to log information about. * @return logger to use for logging. */ public static Log getLog(final Class<?> clazz) { try { // check that we're not logging ourselves if (LogSpi.class.isAssignableFrom(clazz)) { throw new IllegalArgumentException(); } // attempt to get an instance.. LogSpi logImpl = (LogSpi) getSpiClass().newInstance(); return new Log(clazz, logImpl); } catch (RuntimeException e) { throw e; } catch (Exception e) { throw new RuntimeException(e); } }
private synchronized static Log getLog() { if (log == null) { log = Log.getLog(Main.class); } return log; } }
@Test public void checkBasicLoggingWithFormating() { for (Log.Level level : Log.Level.values()) { final String FORMAT = "Message: {0}"; final String EXPECTED_MSG = "Message: " + level; MockLogSpi spi = new MockLogSpi(); spi._isloggable = true; Log log = Log.getLog(String.class, spi); if (Log.Level.ERROR.equals(level)) { log.error(FORMAT, level); } else if (Log.Level.INFO.equals(level)) { log.info(FORMAT, level); } else if (Log.Level.OK.equals(level)) { log.ok(FORMAT, level); } else if (Log.Level.WARN.equals(level)) { log.warn(FORMAT, level); } assertEquals(spi._message, EXPECTED_MSG); assertNull(spi._exception); assertTrue(spi._isloggable); assertEquals(level, spi._level); assertEquals(spi._class, String.class); } }
private void checkCCL() { if (getContextClassLoader() == null) { _log.error(new Throwable(), "The CCL of thread ''{0}'' was null after initialization. The CCL of current thread ''{1}'' is {2}", getName(), Thread.currentThread().getName(), Thread.currentThread().getContextClassLoader()); } else { _log.info("Creating thread ''{0}'' with a non-null CCL", getName()); } }
public static void dispose(final ConnectorPoolKey connectorPoolKey) { synchronized (POOLS) { ObjectPool<PoolableConnector> pool = POOLS.remove(connectorPoolKey); if (null != pool) { try { pool.shutdown(); } catch (Exception e) { LOG.warn(e, "Failed to close pool: {0}", pool); } } } }
public static void logOpExit( Log opLog, ConnectorOperationalContext opContext, Class<?> opClass, String methodName) { if (!opLog.isLoggable(SpiOperationLoggingUtil.LOG_LEVEL)) { return; } StringBuilder sb = new StringBuilder(); appendInstanceName(sb, opContext); sb.append("Return"); opLog.log(opClass, methodName, SpiOperationLoggingUtil.LOG_LEVEL, sb.toString(), null); }
public boolean isOk() { return isLoggable(Level.OK); }
public void info(Throwable ex, String format, Object... args) { log(Level.INFO, ex, format, args); }