We Keep Coding

How to disable error logs being printed to the console during unit tests execution with log4j2?

After upgrading to Log4j2, error logs are printing to console during unit tests execution.
I tried to add status=FATAL in the configuration file to avoid error printing on console.
# ----------------------------------------------------------------
# LOGGING
# ----------------------------------------------------------------
# Note - this section is similar to the log4j2 properties syntax
# https://logging.apache.org/log4j/2.x/manual/configuration.html#Properties
status=FATAL;
test.*.log4j2.rootLogger.level=INFO;
*.*.log4j2.rootLogger.level=INFO;
*.*.log4j2.rootLogger.appenderRefs=(APPLICATION);
*.*.log4j2.appenders=(APPLICATION);
*.*.log4j2.appender.APPLICATION.type=AmazonRollingRandomAccessFile;
*.*.log4j2.appender.APPLICATION.name=APPLICATION;
*.*.log4j2.appender.APPLICATION.filePattern="var/output/logs/$APP.%d{yyyy-MM-dd-HH}";
*.*.log4j2.appender.APPLICATION.layout.type=PatternLayout;
# Standard log format but with the purchase id appended after the message.
# This location is to not break rtla processing, which parses everything up-to & including the logger (%c)
*.*.log4j2.appender.APPLICATION.layout.pattern="%d{DATE} [%p] %X{RequestId} (%t) %c: %m [Purchase: %X{PurchaseId}]%n";
The reference doc.
But seems it is not taking status into consideration and it is still printing logs on console.
I tried with all the options below as well, but no luck:
status=FATAL; ..log4j2.status=INFO; ..log4j2.status=ERROR;

The status of the Configuration only relates to the internal logging of log4j2 itself, i.e. you can use it to debug your configuration of log4j2, but it is not used for your actual application.
If you want to disable all logging for your application, you can set the ThresholdFilter of your configuration to off:
filter.threshold.type = ThresholdFilter
filter.threshold.level = off
or you can set your root logger to level = off (provided you don't have any other loggers defined):
rootLogger.level = off
A complete example of something that would work:
status = warn
name = TestConfig
filter.threshold.type = ThresholdFilter
filter.threshold.level = off
appender.list.type = List
appender.list.name = List
appender.list.filter.threshold.type = ThresholdFilter
appender.list.filter.threshold.level = trace
logger.whatever.name = com.relentlesscoding.logging
logger.whatever.level = trace
logger.whatever.additivity = false
logger.whatever.appenderRef.whatever.ref = List
rootLogger.level = trace

java util logging configure filter in properties file

I have a maven project where I have written a java.util.logging filter as below.
package com.xyz.filters;
import java.util.logging.Filter;
import java.util.logging.LogRecord;
class CustomFilter implements Filter {
public boolean isLoggable(LogRecord record) {
return record.getLoggerName().indexOf("com.package.name") != -1;
}
}
I have a properties file in which I have configured the Console and File handlers and need to add a filter in addition to get rid of unwanted logs in the file.
I added the filter as follows:
java.util.logging.FileHandler.filter = com.xyz.filters.CustomFilter
However the filter is not applied. What am I doing wrong here.
UPDATE: Adding the configuration file
############################################################
# Default Logging Configuration File
#
# You can use a different file by specifying a filename
# with the java.util.logging.config.file system property.
# For example java -Djava.util.logging.config.file=myfile
############################################################
############################################################
# Global properties
# NOTE: this configuration file use to get the handler list,
# Properties(except level property) define for each handler
# may be not available because LogRecords handover to log4j
# appenders in runtime.
############################################################
# "handlers" specifies a comma separated list of log Handler
# classes. These handlers will be installed during VM startup.
# Note that these classes must be on the system classpath.
# By default we only configure a ConsoleHandler, which will only
# show messages at the INFO and above levels.
#handlers= java.util.logging.ConsoleHandler
# To also add the FileHandler, use the following line instead.
#handlers= java.util.logging.FileHandler
# Add org.wso2.carbon.bootstrap.logging.handlers.LogEventHandler to handlers if you need to push java logs to LOGEVENT appender
handlers=java.util.logging.FileHandler, java.util.logging.ConsoleHandler
# Default global logging level.
# This specifies which kinds of events are logged across
# all loggers. For any given facility this global level
# can be overriden by a facility specific level
# Note that the ConsoleHandler also has a separate level
# setting to limit messages printed to the console.
.level= INFO
############################################################
# Handler specific properties.
# Describes specific configuration info for Handlers.
#
java.util.logging.FileHandler.level = FINE
java.util.logging.FileHandler.pattern = /path/to/custom.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format = [%1$tY-%1$tm-%1$td %1$tk:%1$tM:%1$tS,%1$tL] %4$s {%2$s} - %5$s %6$s %n
java.util.logging.FileHandler.filter = om.xyz.filters.CustomFilter
java.util.logging.ConsoleHandler.level = INFO
############################################################
# Facility specific properties.
# Provides extra control for each logger.
############################################################
# For example, set the com.xyz.foo logger to only log SEVERE
# messages:
#com.xyz.foo.level = SEVERE
com.package.name.level = FINE

The problem was the missing access modifier.
When the class was not specified with an access modifier it defaults to private-package which is only visible within the package. Therefore, the FileHandler reads the .filter property as null. When it is changed as public the filter was taken. The corrected code can be found below.
public class CustomFilter implements Filter {
public boolean isLoggable(LogRecord record) {
return record.getLoggerName().indexOf("com.package.name") != -1;
}
}

This is possibly not a full answer to your question, but it seems to me that you are trying to filter out your logs in Web Application from a useless noise. I actually wrote an Open Source library that deals with this issue. You can configure the package that is relevant to you and the utility will very smartly filter out the stacktrace in such a way that you will still see the trace including "caused by" trace but the useless packages will be filtered out. You can get this library as a Maven artifact (including javadoc and sources) or as a source code that you can modify by yourself. Here is an article that describes what the Utility does and where to get it. Open Source Java library with stack trace filtering, Silent String parsing Unicode converter and Version comparison. See the paragraph "Stacktrace noise filter"

Log4j config - different logs to different files

This might be a very easy question for some, but personally I find Log4j config to be nightmarishly difficult and that learning to perform brain surgery might be less challenging.
I am trying to lave multiple loggers logging into different files.
Here is what I have in my log4j.properties file:
# Root logger option
log4j.rootLogger=INFO, file, admin
# Direct log messages to a log file
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=/home/nick/logging/file.log
log4j.appender.file.MaxFileSize=1MB
log4j.appender.file.MaxBackupIndex=1
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1} - %m%n
log4j.appender.admin=org.apache.log4j.RollingFileAppender
log4j.appender.admin.File=/home/nick/logging/admin.log
log4j.appender.admin.MaxFileSize=1MB
log4j.appender.admin.MaxBackupIndex=1
log4j.appender.admin.layout=org.apache.log4j.PatternLayout
log4j.appender.admin.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1} - %m%n
And here is my (very simple) Java app used to test the config:
public static void main(String[] args) throws Exception {
Properties resource = new Properties();
InputStream in = new FileInputStream("/home/nick/logging/log4j.properties");
resource.load(in);
PropertyConfigurator.configure(resource);
Logger admin = Logger.getLogger("admin");
Logger file = Logger.getLogger("file");
admin.info("hello admin");
file.info("hello file");
}
I have 2 problems:
One problem I always get an exception in the line PropertyConfigurator.configure(resource);:
java.io.FileNotFoundException: /home/nick/logging (Is a directory)
at java.io.FileOutputStream.open(Native Method)
at java.io.FileOutputStream.<init>(FileOutputStream.java:212)
at java.io.FileOutputStream.<init>(FileOutputStream.java:136)
at org.apache.log4j.FileAppender.setFile(FileAppender.java:289)
at org.apache.log4j.RollingFileAppender.setFile(RollingFileAppender.java:167)
at org.apache.log4j.FileAppender.activateOptions(FileAppender.java:163)
at org.apache.log4j.config.PropertySetter.activate(PropertySetter.java:256)
The 2nd problem is that both messages are written to both logs. Here is the actual result:
File admin:log:
2014-04-27 11:55:30 INFO admin - hello admin
2014-04-27 11:55:30 INFO file - hello file
File file.log:
2014-04-27 11:55:30 INFO admin - hello admin
2014-04-27 11:55:30 INFO file - hello file
Here is the required result:
File admin:log:
2014-04-27 11:55:30 INFO admin - hello admin
File file.log:
2014-04-27 11:55:30 INFO file - hello file
What is causing the exception, and how can I achieve the required result?

Log4J makes a distinction between loggers, which are responsible for generating log messages, and appenders, which are responsible for sending those messages somewhere (a file, the console, a database, etc.). Loggers form a hierarchy, the root logger is the parent of the logger named admin, which is the parent of admin.component1, etc., and you can attach appenders to any logger in the hierarchy. By default a logger will send messages to all appenders that are attached directly to it, or to any of its ancestors in the hierarchy (this is why loggers are conventionally named like Java classes, e.g. you can control logging for com.example.Class1 and com.example.subpkg.AnotherClass by configuring the com.example logger).
Loggers and appenders form separate namespaces and this is the source of your confusion - the logger named admin and the appender named admin are two separate entities.
The configuration you have given in the question defines one logger (the root logger) which sends all the messages it generates to two separate appenders, one for each of the two files. Your code then requests two different loggers and generates one log message with each logger. Both these loggers inherit the appender configuration from the root logger, so they both send their messages to both of the configured appenders.
Instead of attaching the two appenders to the root logger, you should attach the file appender to the file logger and the admin appender to the admin logger:
log4j.rootLogger=INFO
log4j.logger.file=INFO, file
log4j.logger.admin=INFO, admin
This way the file logger will send messages only to file.log, the admin logger only to admin.log, and all messages from other loggers will be silently discarded, as there are no appenders attached to the root.
The additivity flag is the exception to this rule - setting a logger's additivity to false essentially disconnects the arrow from a logger up to its parent, so messages generated by that logger (or flowing into it from one of its children) will not go any further up the tree, they will only go to appenders attached directly to the logger in question.

To answer my own question, this is what I needed:
log4j.logger.file=DEBUG, fileAppender
log4j.logger.admin=DEBUG, adminAppender
log4j.additivity.file=false
log4j.additivity.admin=false
log4j.appender.fileAppender=org.apache.log4j.RollingFileAppender
log4j.appender.fileAppender.File=/home/nick/logging/file.log
log4j.appender.fileAppender.MaxFileSize=1MB
log4j.appender.fileAppender.MaxBackupIndex=1
log4j.appender.fileAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.fileAppender.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1} - %m%n
log4j.appender.adminAppender=org.apache.log4j.RollingFileAppender
log4j.appender.adminAppender.File=/home/nick/logging/admin.log
log4j.appender.adminAppender.MaxFileSize=1MB
log4j.appender.adminAppender.MaxBackupIndex=1
log4j.appender.adminAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.adminAppender.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1} - %m%n

You don't need to load the properties file. Just place it inside the src folder that will automatically added in class path.
Sample code:
public static void main(String[] args) throws Exception {
Logger admin = Logger.getLogger("admin");
Logger file = Logger.getLogger("file");
admin.info("hello admin");
file.info("hello file");
}

First: log4j recommands to use xml format file for properties.
Second: its better to load the properties file in the classloader.
Third: there is inheritance in logger, but you can cut it with additivity property see log4j.properties file - multiple loggers in same class

disable output to log4j.rootLogger

I am having problem that even though I specify the property log4j.additivity=false ,still log messages are getting displayed in both logs (Root log and intended log).
But I want to log only in intended log file how can I achieve it through configuration in properties file.
I am not a log4j expert so any help is appreciated.
my log file looks like this
#==============================================
# RIPNET Logger (..//logs everything under the sun)
#==============================================
log4j.rootLogger=INFO, RIPNETappender
log4j.appender.RIPNETappender=org.apache.log4j.DailyRollingFileAppender
log4j.appender.RIPNETappender.layout=org.apache.log4j.PatternLayout
log4j.appender.RIPNETappender.layout.ConversionPattern=%d %p [%t:%c] - <%m>%n
log4j.appender.RIPNETappender.File=..//logs//RIPNET.log
#====================================
# WorkOrder Logger
#====================================
log4j.logger.com.reino.ripnet.servlet.alarm=INFO, WorkOrderAppender
log4j.appender.WorkOrderAppender=org.apache.log4j.DailyRollingFileAppender
log4j.additivity.com.reino.ripnet.servlet.alarm=false
log4j.appender.WorkOrderAppender.File=..//logs//WorkOrder.xml.log
log4j.appender.WorkOrderAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.WorkOrderAppender.layout.ConversionPattern=%d %p [%t:%c] - <%m>%n
though i set the value
log4j.additivity.com.reino.ripnet.servlet.alarm=false
the log messages are still getting logged in root log
i even tried setting
log4j.additivity.WorkOrderAppender=false
in the code i call the logger by
Logger logger = Logger.getLogger("WorkOrderAppender");
i also tried using
Logger logger = Logger.getLogger(getClass());
but still no use

You are mixing Loggers and appenders. Additivity can be configured on a logger, and the Logger takes the <severity level> and an <appender name> as argument. Look closely at how I renamed your WorkOrder* names (* = {Appender, Logger}).
Thus, the combination of
log4j.logger.WorkOrderLogger=INFO, WorkOrderAppender
log4j.additivity.WorkOrderLogger=false
and
Logger logger = Logger.getLogger("WorkOrderLogger");
should work.

Creating multiple logs in log4j causing weird effects

I am trying to create multiple logs in Log4j, but I am facing a weird problem. Here's the log4j.properties and the code implementing it.
# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILEALL
# Define the file appender
log4j.appender.FILEALL=org.apache.log4j.FileAppender
log4j.appender.FILEALL.File=${logfile.name}
# Define the layout for file appender
log4j.appender.FILEALL.layout=org.apache.log4j.HTMLLayout
#log4j.appender.FILEMAIN=org.apache.log4j.FileAppender
#log4j.appender.FILEMAIN.File=${logfilemain.name}
#log4j.appender.FILEMAIN.layout=org.apache.log4j.HTMLLayout
I have added the statement when running both and removed the original one
log4j.rootLogger = DEBUG, FILEALL , FILEMAIN
And this is the java code:
System.setProperty("logfile.name", savePath1);
// System.setProperty("logfilemain.name", savePath1);
logger = Logger.getLogger(HarishLog.class.getName());
PropertyConfigurator.configure("log4j.properties");
The code works perfectly fine till I make one log, but as soon as I enable the setting for 2nd log in either the properties or the javafile, nothing happens.
Besides I am unable to put a different name at
log4j.appender.FILEALL.File=${logfile.name}
it only works for logfile.name and logfilea.name, It doesn't work for any other name if I change it both in the javacode and the properties folder. Why is this???
Thank you

This works for me:
log4j.rootLogger = DEBUG, FILEALL, FILEMAIN
log4j.appender.FILEALL=org.apache.log4j.FileAppender
log4j.appender.FILEALL.File=${logfile.name}
log4j.appender.FILEALL.layout=org.apache.log4j.HTMLLayout
log4j.appender.FILEMAIN=org.apache.log4j.FileAppender
log4j.appender.FILEMAIN.File=${logfilemain.name}
log4j.appender.FILEMAIN.layout=org.apache.log4j.HTMLLayout
import org.apache.log4j.Logger;
public class LogTest {
public static void main(final String... args) {
System.setProperty("logfile.name", "logall.txt");
System.setProperty("logfilemain.name", "logmain.txt");
Logger logger = Logger.getLogger(LogTest.class.getName());
logger.info("hello");
}
}
If you're still having problems, try adding:
log4j.debug = true
to the beginning of your log4j.properties, and check the output messages.