下面列出了org.apache.log4j.Logger#log ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void sendAndAssertFail(Logger logger) throws Throwable {
/*
* Log4j internally defines levels as multiples of 10000. So if we
* create levels directly using count, the level will be set as the
* default.
*/
int level = 20000;
try {
logger.log(Level.toLevel(level), "Test Msg");
} catch (FlumeException ex) {
ex.printStackTrace();
throw ex.getCause();
}
Transaction transaction = ch.getTransaction();
transaction.begin();
Event event = ch.take();
Assert.assertNull(event);
transaction.commit();
transaction.close();
}
@Test(expected = EventDeliveryException.class)
public void testSlowness() throws Throwable {
ch = new SlowMemoryChannel(2000);
Configurables.configure(ch, new Context());
configureSource();
props.put("log4j.appender.out2.Timeout", "1000");
props.put("log4j.appender.out2.layout", "org.apache.log4j.PatternLayout");
props.put("log4j.appender.out2.layout.ConversionPattern",
"%-5p [%t]: %m%n");
PropertyConfigurator.configure(props);
Logger logger = LogManager.getLogger(TestLog4jAppender.class);
Thread.currentThread().setName("Log4jAppenderTest");
int level = 10000;
String msg = "This is log message number" + String.valueOf(1);
try {
logger.log(Level.toLevel(level), msg);
} catch (FlumeException ex) {
throw ex.getCause();
}
}
/**
* Simple dumping of request data to logger.
*
* @param request {@link HttpServletRequest} to be dumped
* @param logger Log4j {@link Logger}
* @param level Log level
*/
public static final void dumpRequest(final HttpServletRequest request, final Logger logger, final Level level) {
logger.log(level, " Query String: " + request.getQueryString());
final Enumeration<String> names = request.getHeaderNames();
while(names.hasMoreElements()) {
final String name = names.nextElement();
final Enumeration<String> values = request.getHeaders(name);
while(values.hasMoreElements()) {
logger.log(level, " " + name + " : " + values.nextElement());
}
}
}
/**
* Write content of stream to log4j.
*
* @param stream stream to log
* @param loggerToUse logger to use
* @param priority priority of log message
* @param message message before stream output
*/
public static void logStream( InputStream stream, Logger loggerToUse, Priority priority, String message) {
try (ByteArrayOutputStream byteStream = new ByteArrayOutputStream()) {
FileUtils.streamToStream(stream, stream.available(), byteStream);
loggerToUse.log( priority, message + ":\n" + byteStream.toString());
} catch( IOException e) {
ProcessUtils.logger.warn( "Unable to log stream", e);
}
}
private void writeMessage(Logger logger, String message, Level level) {
Exception loggingException = null;
synchronized (auditLogManager) {
logger.log(level, message);
loggingException = auditLogManager.getException();
}
if (loggingException != null) {
LOGGER.error(Messages.AUDIT_LOGGING_FAILED, loggingException);
}
}
/**
* Simple test of NTEventLogAppender.
*/
public void testSimple() {
BasicConfigurator.configure(new NTEventLogAppender());
Logger logger = Logger.getLogger("org.apache.log4j.nt.NTEventLogAppenderTest");
int i = 0;
logger.debug( "Message " + i++);
logger.info( "Message " + i++);
logger.warn( "Message " + i++);
logger.error( "Message " + i++);
logger.log(Level.FATAL, "Message " + i++);
logger.debug("Message " + i++, new Exception("Just testing."));
}
@Override
public <T extends Throwable> T log(final String className, final String methodName,
final LogLevel logLevel, String message, final T throwable) {
// Make sure logging has been initialized.
if (!initialized.get()) {
if (!Logger.getRootLogger().getAllAppenders().hasMoreElements()) {
LogConfig.getInstance().enableSimplifiedLogging();
}
initialized.set(true);
}
Logger logger = getLogger(className);
// If logging has been turned off simply return.
if (!logger.isEnabledFor(logLevel.getLevel())) {
return throwable;
}
// Track the methods logged.
LoggingProperties.getInstance().putProperty("method", methodName);
message = methodName + " : " + message;
// Write the log entry.
logger.log(logLevel.getLevel(), message, throwable);
return throwable;
}
public static void exception(Logger LOGGER,Exception ex)
{
StackTraceElement ste = new Throwable().getStackTrace()[1];
String clsName=ste.getClassName();
String pkage = clsName.substring(clsName.lastIndexOf(".",clsName.lastIndexOf(".")-1)+1, clsName.length());
clsName=clsName.substring(clsName.lastIndexOf(".")+1, clsName.length());
if(clsName.isEmpty()) return;
//get a proper instance
Logger subLog = LOGGER.getLogger(clsName);
if(subLog==null) return;
subLog.log(Level.ERROR, " ("+pkage+","
+ste.getLineNumber()+","+ste.getMethodName()+" )"+stackTraceToStr(ex));
}
public static void exception(Logger LOGGER,Throwable throwable)
{
StackTraceElement ste = new Throwable().getStackTrace()[1];
String clsName=ste.getClassName();
String pkage = clsName.substring(clsName.lastIndexOf(".",clsName.lastIndexOf(".")-1)+1, clsName.length());
clsName=clsName.substring(clsName.lastIndexOf(".")+1, clsName.length());
if(clsName.isEmpty()) return;
//get a proper instance
Logger subLog = LOGGER.getLogger(clsName);
if(subLog==null) return;
subLog.log(Level.ERROR, " ("+pkage+","
+ste.getLineNumber()+","+ste.getMethodName()+" )"+stackTraceToStr(throwable));
}
public static void debug(String logcontent)
{
StackTraceElement ste = new Throwable().getStackTrace()[1];
String clsName=ste.getClassName();
String pkage = clsName.substring(clsName.lastIndexOf(".",clsName.lastIndexOf(".")-1)+1, clsName.length());
clsName=clsName.substring(clsName.lastIndexOf(".")+1, clsName.length());
if(clsName.isEmpty()) return;
//get a proper instance
Logger subLog = Logger.getRootLogger();
if(subLog==null) return;
subLog.log(Level.DEBUG, " ("+pkage+","+ste.getLineNumber()+","+ste.getMethodName()+" )"+logcontent);
}
public static void debug(String pattern, Object ... arguments)
{
MessageFormat temp = new MessageFormat(pattern);
String logcontent=temp.format(arguments);
StackTraceElement ste = new Throwable().getStackTrace()[1];
String clsName=ste.getClassName();
String pkage = clsName.substring(clsName.lastIndexOf(".",clsName.lastIndexOf(".")-1)+1, clsName.length());
clsName=clsName.substring(clsName.lastIndexOf(".")+1, clsName.length());
if(clsName.isEmpty()) return;
//get a proper instance
Logger subLog = Logger.getRootLogger();
if(subLog==null) return;
subLog.log(Level.DEBUG, " ("+pkage+","
+ste.getLineNumber()+","+ste.getMethodName()+" )"+logcontent);
}
/**
* Print out the given exception in preferred form into the given logger.
*/
public static void logException(Logger logger, String message, Throwable t, Level level) {
String completeMessage = ExceptionUtils.getMessage(message, t);
if (!StringUtils.isEmpty(completeMessage)) {
logger.log(level, completeMessage);
}
if (t != null) {
logger.log(level, "Error details:\n" + ExceptionUtils.stackTraceToString(t));
}
}
/**
* Iterates through and logs (at the given level) all attributes and
* parameters of the given request onto the given Logger
*
* @param request
* @param logger
*/
public static void logRequestContents(Logger logger, Level level, HttpServletRequest request) {
if (logger.isEnabledFor(level)) {
logger.log(level, "--------------------");
logger.log(level, "HttpRequest attributes:");
for (Enumeration e = request.getAttributeNames(); e.hasMoreElements();) {
String attrName = (String) e.nextElement();
Object attrValue = request.getAttribute(attrName);
if (attrValue.getClass().isArray()) {
logCollection(logger, level, attrName, Arrays.asList((Object[]) attrValue));
}
else if (attrValue instanceof Collection) {
logCollection(logger, level, attrName, (Collection) attrValue);
}
else if (attrValue instanceof Map) {
logMap(logger, level, attrName, (Map) attrValue);
}
else {
logObject(logger, level, attrName, attrValue);
}
}
logger.log(level, "--------------------");
logger.log(level, "HttpRequest parameters:");
for (Enumeration i = request.getParameterNames(); i.hasMoreElements();) {
String paramName = (String) i.nextElement();
String[] paramValues = (String[]) request.getParameterValues(paramName);
logArray(logger, level, paramName, paramValues);
}
logger.log(level, "--------------------");
}
}
@Test
public void testLog4jAppender() throws IOException {
PropertyConfigurator.configure(props);
Logger logger = LogManager.getLogger(TestLog4jAppender.class);
for(int count = 0; count <= 1000; count++){
/*
* Log4j internally defines levels as multiples of 10000. So if we
* create levels directly using count, the level will be set as the
* default.
*/
int level = ((count % 5)+1)*10000;
String msg = "This is log message number" + String.valueOf(count);
logger.log(Level.toLevel(level), msg);
Transaction transaction = ch.getTransaction();
transaction.begin();
Event event = ch.take();
Assert.assertNotNull(event);
Assert.assertEquals(new String(event.getBody(), "UTF8"), msg);
Map<String, String> hdrs = event.getHeaders();
Assert.assertNotNull(hdrs.get(Log4jAvroHeaders.TIMESTAMP.toString()));
Assert.assertEquals(Level.toLevel(level),
Level.toLevel(Integer.valueOf(hdrs.get(Log4jAvroHeaders.LOG_LEVEL
.toString()))
));
Assert.assertEquals(logger.getName(),
hdrs.get(Log4jAvroHeaders.LOGGER_NAME.toString()));
Assert.assertEquals("UTF8",
hdrs.get(Log4jAvroHeaders.MESSAGE_ENCODING.toString()));
transaction.commit();
transaction.close();
}
}
@Test
public void testLog4jAppender() throws IOException {
configureSource();
PropertyConfigurator.configure(props);
Logger logger = LogManager.getLogger(TestLog4jAppender.class);
for(int count = 0; count <= 1000; count++){
/*
* Log4j internally defines levels as multiples of 10000. So if we
* create levels directly using count, the level will be set as the
* default.
*/
int level = ((count % 5)+1)*10000;
String msg = "This is log message number" + String.valueOf(count);
logger.log(Level.toLevel(level), msg);
Transaction transaction = ch.getTransaction();
transaction.begin();
Event event = ch.take();
Assert.assertNotNull(event);
Assert.assertEquals(new String(event.getBody(), "UTF8"), msg);
Map<String, String> hdrs = event.getHeaders();
Assert.assertNotNull(hdrs.get(Log4jAvroHeaders.TIMESTAMP.toString()));
Assert.assertEquals(Level.toLevel(level),
Level.toLevel(Integer.valueOf(hdrs.get(Log4jAvroHeaders.LOG_LEVEL
.toString()))
));
Assert.assertEquals(logger.getName(),
hdrs.get(Log4jAvroHeaders.LOGGER_NAME.toString()));
Assert.assertEquals("UTF8",
hdrs.get(Log4jAvroHeaders.MESSAGE_ENCODING.toString()));
transaction.commit();
transaction.close();
}
}
public void record(Logger logger, Level p, String msg, Object... params) {
if (logger.isEnabledFor(p)) {
StringBuilder buf = new StringBuilder();
toString(buf, msg, params);
String entry = buf.toString();
log(entry);
logger.log(p, entry);
} else {
log(msg, params);
}
}
static void create(Logger logger) {
try {
File logFile = createLogFile();
WriterAppender appender = createAppender(logFile);
logger.addAppender(appender);
} catch (Exception e) {
logger.log(Level.ERROR, e.getMessage(), e);
}
}
private static void logThing(Logger logger, Level level, String thingName, Object thing) {
logger.log(level, " '" + thingName + "' => " + thing);
}
@Test
public void testLayout() throws IOException {
configureSource();
props.put("log4j.appender.out2.layout", "org.apache.log4j.PatternLayout");
props.put("log4j.appender.out2.layout.ConversionPattern",
"%-5p [%t]: %m%n");
PropertyConfigurator.configure(props);
Logger logger = LogManager.getLogger(TestLog4jAppender.class);
Thread.currentThread().setName("Log4jAppenderTest");
for(int count = 0; count <= 100; count++){
/*
* Log4j internally defines levels as multiples of 10000. So if we
* create levels directly using count, the level will be set as the
* default.
*/
int level = ((count % 5)+1)*10000;
String msg = "This is log message number" + String.valueOf(count);
logger.log(Level.toLevel(level), msg);
Transaction transaction = ch.getTransaction();
transaction.begin();
Event event = ch.take();
Assert.assertNotNull(event);
StringBuilder builder = new StringBuilder();
builder.append("[").append("Log4jAppenderTest").append("]: ")
.append(msg);
//INFO seems to insert an extra space, so lets split the string.
String eventBody = new String(event.getBody(), "UTF-8");
String eventLevel = eventBody.split("\\s+")[0];
Assert.assertEquals(Level.toLevel(level).toString(), eventLevel);
Assert.assertEquals(
new String(event.getBody(), "UTF8").trim()
.substring(eventLevel.length()).trim(), builder.toString());
Map<String, String> hdrs = event.getHeaders();
Assert.assertNotNull(hdrs.get(Log4jAvroHeaders.TIMESTAMP.toString()));
Assert.assertEquals(Level.toLevel(level),
Level.toLevel(Integer.parseInt(hdrs.get(Log4jAvroHeaders.LOG_LEVEL
.toString()))));
Assert.assertEquals(logger.getName(),
hdrs.get(Log4jAvroHeaders.LOGGER_NAME.toString()));
Assert.assertEquals("UTF8",
hdrs.get(Log4jAvroHeaders.MESSAGE_ENCODING.toString()));
transaction.commit();
transaction.close();
}
}
@Test
public void testLayout() throws IOException {
props.put("log4j.appender.out2.layout", "org.apache.log4j.PatternLayout");
props.put("log4j.appender.out2.layout.ConversionPattern",
"%-5p [%t]: %m%n");
PropertyConfigurator.configure(props);
Logger logger = LogManager.getLogger(TestLog4jAppender.class);
Thread.currentThread().setName("Log4jAppenderTest");
for(int count = 0; count <= 100; count++){
/*
* Log4j internally defines levels as multiples of 10000. So if we
* create levels directly using count, the level will be set as the
* default.
*/
int level = ((count % 5)+1)*10000;
String msg = "This is log message number" + String.valueOf(count);
logger.log(Level.toLevel(level), msg);
Transaction transaction = ch.getTransaction();
transaction.begin();
Event event = ch.take();
Assert.assertNotNull(event);
StringBuilder builder = new StringBuilder();
builder.append("[").append("Log4jAppenderTest").append("]: ")
.append(msg);
//INFO seems to insert an extra space, so lets split the string.
String eventBody = new String(event.getBody(), "UTF-8");
String eventLevel = eventBody.split("\\s+")[0];
Assert.assertEquals(Level.toLevel(level).toString(), eventLevel);
Assert.assertEquals(
new String(event.getBody(), "UTF8").trim()
.substring(eventLevel.length()).trim(), builder.toString());
Map<String, String> hdrs = event.getHeaders();
Assert.assertNotNull(hdrs.get(Log4jAvroHeaders.TIMESTAMP.toString()));
Assert.assertEquals(Level.toLevel(level),
Level.toLevel(Integer.parseInt(hdrs.get(Log4jAvroHeaders.LOG_LEVEL
.toString()))));
Assert.assertEquals(logger.getName(),
hdrs.get(Log4jAvroHeaders.LOGGER_NAME.toString()));
Assert.assertEquals("UTF8",
hdrs.get(Log4jAvroHeaders.MESSAGE_ENCODING.toString()));
transaction.commit();
transaction.close();
}
}