I´m using commons-httpclient 3.1 in an integration test suite. The default logging for HttpClient is extremely noisy and I can't seem to turn it off. I've tried following the instructions here but none of them make any difference.
Mostly I just need to make the org.apache.http.wire logger shut up. Part of the problem is that I don't know what type of logger HttpClient is trying to use. I've never used this library before. I tried creating a log4j.properties file and dropping it in my test/resources folder, modifying the master logging.properties file in jre/lib, and sending in the various logging options to Maven as specified on the logging page, and none of them make any difference.
UPDATE: A correction: it appears the output in question is actually originating through jwebunit's usage of HttpClient, not my own. Either way, it's not desirable.
UPDATE: Thanks for the attempts so far. I've tried everything suggested below but still no luck. I have a file commons-logging.properties in my src/test/resources folder with the following contents
org.apache.commons.logging.LogFactory=org.apache.commons.logging.impl.Log4jFactory
log4j.configuration=log4j.properties
and a file log4j.properties in the same folder with the following contents
log4j.rootLogger=ERROR, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%c] %m%n
#This is the line that should make httpclient shut up
log4j.logger.org.apache.http=ERROR
However, when I run my tests I still get a bunch of output like this:
21:57:41.413 [main] DEBUG org.apache.http.wire - << " [\r][\n]"
21:57:41.413 [main] DEBUG org.apache.http.wire - << "[\r][\n]"
21:57:41.413 [main] DEBUG org.apache.http.wire - << " [\r][\n]"
21:57:41.413 [main] DEBUG org.apache.http.wire - << " </ul>[\n]"
21:57:41.413 [main] DEBUG org.apache.http.wire - << " [\n]"
21:57:41.424 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.425 [main] DEBUG org.apache.http.wire - << "[\r][\n]"
21:57:41.425 [main] DEBUG org.apache.http.wire - << "[\r][\n]"
21:57:41.425 [main] DEBUG org.apache.http.wire - << " </div>[\r][\n]"
21:57:41.425 [main] DEBUG org.apache.http.wire - << " </li>[\r][\n]"
21:57:41.425 [main] DEBUG org.apache.http.wire - << " [\r][\n]"
21:57:41.425 [main] DEBUG org.apache.http.wire - << " [\r][\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << " </ul>[\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << "</div>[\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << "</div>[\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.433 [main] DEBUG org.apache.http.wire - << "<div class="details">[\n]"
21:57:41.442 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.443 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.443 [main] DEBUG org.apache.http.wire - << "<div class="details-body details-precis ">[\n]
"
21:57:41.443 [main] DEBUG org.apache.http.wire - << "<div class="details-state">[\n]"
21:57:41.443 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.443 [main] DEBUG org.apache.http.wire - << "</div>[\n]"
21:57:41.443 [main] DEBUG org.apache.http.wire - << "</div>[\n]"
21:57:41.443 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "</div>[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "</div>[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "</div>[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "[\n]"
21:57:41.455 [main] DEBUG org.apache.http.wire - << "[\r][\n]"
Destroying 1 processes21:57:41.465 [main] DEBUG org.apache.http.wire - << "[\r][\n]"
This output for everything that comes across the wire is making this library unusable for me...that is until I can figure out how to turn it off. Is there anything special I need to do to get this log configuration read in?
Update log4j.properties to include:
log4j.logger.httpclient.wire.header=WARN
log4j.logger.httpclient.wire.content=WARN
Note that if Log4j library is not installed, HttpClient (and therefore JWebUnit) will use logback. In this situation, create or edit logback.xml to include:
<configuration>
<logger name="org.apache" level="WARN" />
<logger name="httpclient" level="WARN" />
</configuration>
Setting the log level to WARN with Log4j using the package name org.apache.commons.httpclient in log4j.properties will not work as expected:
log4j.logger.org.apache.commons.httpclient=WARN
This is because the source for HttpClient (v3.1) uses the following log names:
public static Wire HEADER_WIRE = new Wire(LogFactory.getLog("httpclient.wire.header"));
public static Wire CONTENT_WIRE = new Wire(LogFactory.getLog("httpclient.wire.content"));
Note: Some of this answer might repeat things you already know (or think you know), but there is a bit of mis-information floating around on this question, so I'm going to start at the beginning and spell it all out
Commons HttpClient uses Commons-Logging for all its logging needs.
Commons-Logging is not a full logging framework, but rather, is a wrapper around several existing logging frameworks
That means that when you want to control the logging output, you (mostly) end up configuring a library other than Commons-Logging, but because Commons-Logging wraps around several other libraries, it's hard for us to guess which one to configure without knowing your exactly setup.
Commons-Logging can log to log4j, but it can also log to java.util.logging (JDK1.4 logging)
Commons-Logging tries to be smart and guess which logging framework you are already using, and send its logs to that.
If you don't already have a logging framework, and are running on a JRE that's 1.4 or above (which you really should be) then it will probably be sending its log messages to the JDK logging (java.util.logging)
Relying on Commons-Logging's autodiscovery mechanism is prone to error. Simply adding log4j.jar onto the classpath would cause it to switch which logging mechanism it uses, which probably isn't what you want
It is preferable for you to explicitly tell Commons-Logging which logging library to use
You can do this by creating a commons-logging.properties file as per these instructions
The steps you want to follow to configure the commons-httpclient logging are
Decide which underlying logging framework you want to use. Historically, the common choices used to be log4j or java.util.logging. In 2022, the common choice is LogBack (also the Spring Framework's default).
Set-up the commons-logging properties file to point to the correct Log implementation. e.g.:
To use log4j, put this into the properties file:
org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JLogger
To use JDK logging set:
org.apache.commons.logging.Log=org.apache.commons.logging.impl.Jdk14Logger.
To use Slf4J:
org.apache.commons.logging.Log=org.apache.logging.slf4j.SLF4JLogger
These can also be set as system properties (e.g. using -D on the command line).
Configure the underlying logging implementation (e.g. log4j) to ignore the messages you don't want, and output the messages you do want.
That's a lot of steps, but that's what it takes. The developers at Apache-commons tend to assume you'll already have a logging framework configured, and they can work out which one it is by auto-discovery.
If that's not true for you, then it tends to be a bit more work to get things running.
For log4j, add the following to log4j.properties (in the application's source directory):
log4j.logger.org.apache=WARN
log4j.logger.httpclient=WARN
For logback, the following logback.xml will kill the noise:
<configuration>
<logger name="org.apache" level="WARN" />
<logger name="httpclient" level="WARN" />
</configuration>
This worked for my tests;
java.util.logging.Logger.getLogger("org.apache.http.wire").setLevel(java.util.logging.Level.FINEST);
java.util.logging.Logger.getLogger("org.apache.http.headers").setLevel(java.util.logging.Level.FINEST);
System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
System.setProperty("org.apache.commons.logging.simplelog.showdatetime", "true");
System.setProperty("org.apache.commons.logging.simplelog.log.httpclient.wire", "ERROR");
System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http", "ERROR");
System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http.headers", "ERROR");
I put this into my log4j config file
log4j.logger.org.apache.http.wire=WARN
This limits the output to Warning level or above
I had this issue while using RestAssured with JUnit. For me this programmatic approach worked:
#BeforeClass
public static void setUpClass() {
ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) org.slf4j.LoggerFactory.getLogger("org.apache.http");
root.setLevel(ch.qos.logback.classic.Level.INFO);
//...
}
It took far too long to find this out, but JWebUnit comes bundled with the Logback logging component, so it won't even use log4j.properties or commons-logging.properties.
Instead, create a file called logback.xml and place it in your source code folder (in my case, src):
<configuration debug="false">
<!-- definition of appender STDOUT -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern>
</encoder>
</appender>
<root level="ERROR">
<!-- appender referenced after it is defined -->
<appender-ref ref="STDOUT"/>
</root>
</configuration>
Logback looks to still be under development and the API seems to still be changing, so this code sample may fail in the future. See also this StackOverflow question.
We use XML, rather than a properties file, to configure our logging output. The following code worked to silence this chatter.
<logger name="org.apache.commons.httpclient">
<level value="fatal"/>
</logger>
<logger name="httpclient.wire.header">
<level value="fatal"/>
</logger>
<logger name="httpclient.wire.content">
<level value="fatal"/>
</logger>
Simple way Log4j and HttpCLient (v3.1 in this case, should work for higher, could require minor changes)
Make sure all the dependencies are correct, and MD5 your downloads!!!!
import org.apache.commons.httpclient.HttpClient;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
---
Logger.getLogger("org.apache.commons.httpclient").setLevel(Level.WARN);
Logger.getLogger("httpclient.wire.header").setLevel(Level.WARN);
Logger.getLogger("httpclient.wire.content").setLevel(Level.WARN);
HttpClient client = new HttpClient();
It may be caused by a dependency bringing in a logging config (which they really should not, unless it's a framework supposed to do so).
I've been plagued by the same issue for quite some time now and finally decided to look into this.
It turned out the issue is that my project had a dependency on http-builder-0.5.2.jar which bundled a log4j.xml file within itself. And sure enough, the log level for org.apache.http.wire was DEBUG! The way I found it was just to go through all the jar files in my dependencies and do "jar tvf" and grepping for log4j.
While this discovery led to the eventual solution of upping the version of my http-builder dependency to 0.6, it still baffles me what must have gone through the developer's mind when bundling the log4j.xml file into the jar file. Anyway, that's probably not relevant to this thread for now. But I figured it's useful to mention this solution I found given that when I was searching for a solution before now, mine never came up. Hopefully someone will find this useful.
I was also having the same problem. The entire console was filled with [main] DEBUG org.apache.http.wire while running the tests.
The solution which worked for me was creating a logback-test.xml
src/test/resources/logback-test.xml as in https://github.com/bonigarcia/webdrivermanager-examples/blob/master/src/test/resources/logback-test.xml (ref - https://github.com/bonigarcia/webdrivermanager/issues/203)
To view my logging infos, I replaced logger name="io.github.bonigarcia" with my package name
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<logger name="com.mypackage" level="DEBUG" />
<logger name="org" level="INFO" />
<logger name="com" level="INFO" />
<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>
it's work for me with add "logback.xml" in class root path and below setting.
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<logger name="org.apache" level="WARN"/>
<logger name="httpclient" level="WARN"/>
</configuration>
In your log4.properties - do you have this set like I do below and no other org.apache.http loggers set in the file?
-org.apache.commons.logging.simplelog.log.org.apache.http=ERROR
Also if you don't have any log level specified for org.apache.http in your log4j properties file then it will inherit the log4j.rootLogger level. So if you have log4j.rootLogger set to let's say ERROR and take out org.apache.http settings in your log4j.properties that should make it only log ERROR messages only by inheritance.
UPDATE:
Create a commons-logging.properties file and add the following line to it. Also make sure this file is in your CLASSPATH.
org.apache.commons.logging.LogFactory=org.apache.commons.logging.impl.Log4jFactory
Added a completed log4j file and the code to invoke it for the OP. This log4j.properties should be in your CLASSPATH. I am assuming stdout for the moment.
log4j.configuration=log4j.properties
log4j.rootLogger=ERROR, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%c] %m%n
log4j.logger.org.apache.http=ERROR
Here is some code that you need to add to your class to invoke the logger.
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class MyClazz
{
private Log log = LogFactory.getLog(MyClazz.class);
//your code for the class
}
I had the same problem with JWebUnit. Please notice that if you use binary distribution then Logback is a default logger. To use log4j with JWebUnit I performed following steps:
removed Logback jars
add lod4j bridge library for sfl4j - slf4j-log4j12-1.6.4.jar
add log4j.properties
Probably you don't have to remove Logback jars but you will need some additional step to force slf4j to use log4j
The following 2 lines solved my problem completely:
Logger.getLogger("org.apache.commons.httpclient").setLevel(Level.ERROR);
Logger.getLogger("httpclient").setLevel(Level.ERROR);
For me, the below lines in the log4j.properties file cleaned up all the mess that came from HttpClient logging... Hurray!!! :)
log4j.logger.org.apache.http.headers=ERROR
log4j.logger.org.apache.http.wire=ERROR
log4j.logger.org.apache.http.impl.conn.PoolingHttpClientConnectionManager=ERROR
log4j.logger.org.apache.http.impl.conn.DefaultManagedHttpClientConnection=ERROR
log4j.logger.org.apache.http.conn.ssl.SSLConnectionSocketFactory=ERROR
log4j.logger.org.springframework.web.client.RestTemplate=ERROR
log4j.logger.org.apache.http.client.protocol.RequestAddCookies=ERROR
log4j.logger.org.apache.http.client.protocol.RequestAuthCache=ERROR
log4j.logger.org.apache.http.impl.execchain.MainClientExec=ERROR
log4j.logger.org.apache.http.impl.conn.DefaultHttpClientConnectionOperator=ERROR
Add the below lines in the log4j property file and it will shut the http logs :- log4j.logger.org.apache.http=OFF
This worked for me.
System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
System.setProperty("org.apache.commons.logging.simplelog.showdatetime", "true");
System.setProperty("org.apache.commons.logging.simplelog.log.httpclient.wire.header", "error");
System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http", "error");
System.setProperty("log4j.logger.org.apache.http", "error");
System.setProperty("log4j.logger.org.apache.http.wire", "error");
System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.commons.httpclient", "error");
For Apache HttpClient 4.5.3, if you want to move the level for all Apache logging to WARN, use:
log4j.logger.org.apache=WARN
Try put
org.apache.commons.logging.Log=org.apache.commons.logging.impl.NoOpLog
in your commons-logging.properties
I was led to this post when searching for solution for similar problem. Tim's answer was very helpful. like Matt Baker, I just want to shut off httpClient log without too much configuration.
As we were not sure which logging implementation underneath common-logging was used, My solution was to force it using log4j by throwing log4j jar file in the class path. Default setting of log4j configuration shuts off common-httpclient debug output. Of course, to make it more robust, you may create common-logging.properties and log4j.properties files to further define your logging configurations.
I had this same problem when running jwebunit integration tests. I fixed it by excluding logback and adding in slf4j-log4j12, like so:
<dependency>
<groupId>net.sourceforge.jwebunit</groupId>
<artifactId>jwebunit-htmlunit-plugin</artifactId>
<version>3.0</version>
<exclusions>
<exclusion>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</dependency>
This took me ages to figure out once, you need this:
log4j.logger.httpclient.wire=ERROR
I guess HttpClient uses "httpclient.wire" as its logger name, not "org.apache.commons.httpclient".
Sneaky buggers.
I experienced such problem after setting HttpComponentsClientHttpRequestFactory for my rest template.
Setting OkHttpClientHttpRequestFactory should solve problem with trash logging.
Try 'log4j.logger.org.apache.http.headers=ERROR'
For me it was very simple solution :
I had to add log4j dependancies in my POM.xml and that resolved unnecessary loggings .
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.6.1</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.6.1</version>
</dependency>
Since Google also leads here even when searching for a log4j2 solution, here is what you can use. Add the following piece of XML code into your log4j2.xml within the Loggers tags:
<logger name="org.apache.http" level="WARN"/>
Working for org.apache.httpcomponents:httpclient:4.5.13 and org.apache.logging.log4j:log4-core:2.14.1.
Simply check the pom.xml file first and update accordingly if needed. And when you see the "[main] DEBUG org.apache.http.wire" multiple times on the screen, just let that happen completely and take time with doing nothing. Just look at your screen for a few... It will start running your suite soon.
Thanks
For Spring (Boot) users:
Spring may load the logging config from logback-spring.xml in order to support Spring "extensions" (currently only profile-based logging levels).
I spent a couple hours experimenting before finding that logback-spring.xml will cause HttpClient logging not to pick up the level.
Renaming to logback.xml finally worked.
(I think this is a different cause worth it's own answer.)
Create a logback.xml file with the following contents:
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<logger name="org.apache" level="WARN"/>
<logger name="httpclient" level="WARN"/>
</configuration>
My project is set up with folder structure src->main->java and src->main->resources. Put this file in the resources folder.
Related
I have a Spring Boot app with the following application.yml
logging:
file: logs/api.log
pattern:
file: "%d %-5level [%thread] %logger{0} : %msg%n"
level:
org.springframework.web: INFO
guru.springframework.controllers: INFO
org.hibernate: INFO
which works fine in tomcat 7 and the api.log file was under /logs directory
when I move the app to tomcat 8.5 all the logs are going to catalina.out
I tried also with
logging:
path: /logs
file: api.log
I made a global search for api.log but the file does not exist on the server
Running spring boot/java test project using maven through terminal is not printing logs.However when I run the project through Intellij(run configuration), it does print logs.
I have tried enable logging for spring boot by enabling logs in application.yml file but it didn't work. I have also observed that since intellij uses java to run the test project logging works however I am using maven from terminal so it doesn't work.
logging:
level:
root: INFO
org.package INFO
Enable logs in spring boot java project that prints stuff on terminal.
Besides from the indentation, you are missing the:
logging:
level:
root: INFO
org.package: INFO
Also, you can configure the Logback for Spring-Boot, here is how to: logback
Basically, creating a logback.xml file in the resources path, with the content of:
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<include resource="org/springframework/boot/logging/logback/base.xml"/>
<logger name="org.springframework.web" level="DEBUG"/>
</configuration>
Here it is also another great tutorial: here
Using spring boot application.yml and logback.xml property files.
I tried with below application.yml properties but its not working.
spring.logging.level.org.apache.kafka:
clients.consumer.ConsumerConfig: INFO
clients.producer.ProducerConfig: INFO
common.utils.AppInfoParser: INFO
Try putting this in config file
<logger name="org.apache.zookeeper" level="OFF"/>
Similarly for kafka.
I'm having problems with my logging where slf4j doesn't log the filename and row number of the message/stacktrace.
Code:
private static Logger log = LoggerFactory.getLogger(SomeService.class);
#Override
public void aService(ServiceAdmin sa) throws Exception {
log.debug(LoggerFactory.class.toString());
log.debug(log.getClass().getName());
log.debug("Setup Example");
SomeService.setDefault(Example.getInstance());
log.debug("Example finished");
}
Log:
2015-04-20 14:47:26.573 DEBUG [main] null:-1 - class org.slf4j.LoggerFactory
2015-04-20 14:47:26.574 DEBUG [main] null:-1 - ch.qos.logback.classic.Logger
2015-04-20 14:47:26.574 DEBUG [main] null:-1 - Setup Example
2015-04-20 14:47:26.575 DEBUG [main] null:-1 - SomeService finished
This is pars of my logback.xml that relates to this class
<logger name="com.bredband.nexusgw.services">
<level value="debug" />
<appender-ref ref="nexusservice" />
</logger>
<appender name="nexusservice"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<File>/var/log/nexus/nexusjgw/jgw/Service.log</File>
<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
<FileNamePattern>/var/log/nexus/nexusjgw/jgw/Service.log.%i
</FileNamePattern>
<MinIndex>1</MinIndex>
<MaxIndex>5</MaxIndex>
</rollingPolicy>
<triggeringPolicy
class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>200MB</MaxFileSize>
</triggeringPolicy>
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>debug</level>
</filter>
<layout class="ch.qos.logback.classic.PatternLayout">
<Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %5p [%t] %F:%L - %m%n</Pattern>
</layout>
</appender>
Has anyone seen this before and can point me in the right direction?
BR
Stefan
-- Update --
I changed the %F to %C, but that didn't change anything in the logs. Then I tried to set debug = "on" in the javac header in my ant file and now it's logging classname and line number.
2015-04-21 08:28:55.910 DEBUG [main] Service.java:20 - class org.slf4j.LoggerFactory
2015-04-21 08:28:55.911 DEBUG [main] Service.java:21 - ch.qos.logback.classic.Logger
2015-04-21 08:28:55.911 DEBUG [main] Service.java:22 - Setup Example
2015-04-21 08:28:55.912 DEBUG [main] Service.java:24 - Example finished
Although this is working, it's not something I've changed before. The only thing that has changed in this project over time is the addition of other external jars. I'm not really sure how adding a duplicate/newer/older version of slf4j in another external jar would affect the logging though, any version should look for the logback file?
-- Update --
After checking alot of historical checkins of the build.xml file I found that we actually had debug = "on" earlier and the problem may actually have been introduced by this parameter beeing set to "off".
Thank you for your help.
BR
Stefan
You should first make sure that you compile your application with debug information. If calling javac directly, then it is the -g command-line parameter. However most build tools (like maven or ant) have a specific way to provide this parameter.
You may also want to replace %F with %C, which should work without the debug information.
This is perhaps a very simple question. How do i disable Hikari-CP debug logs? In my log file i have lots of these messages
DEBUG [.zaxxer.hikari.pool.HikariPool:] - Before cleanup pool stats HikariPool-0 (total=10, inUse=0, avail=10, waiting=0)
DEBUG [.zaxxer.hikari.pool.HikariPool:] - After cleanup pool stats HikariPool-0 (total=10, inUse=0, avail=10, waiting=0)
and in my log4jConfig.xml:
<logger name="org.zaxxer.hikari">
<level value="error"/>
</logger>
Can someone please tell me what is wrong with the logger configuration?
Thanks!
The logger name should be com.zaxxer.hikari not org.zaxxer.hikari.
The class name is displaying in you DEBUG info:
DEBUG [.zaxxer.hikari.pool.HikariPool:] - ...
here the class name is zaxxer.hikari.pool.HikariPool, Just modify config file as being disaplayed.
I use logback logger, there is a file named logback.xml located in resources folder, to disable HikariPool logging, i write following config:
<configuration>
...
<logger name="com.zaxxer.hikari.pool.PoolBase" level="ERROR"/>
<logger name="com.zaxxer.hikari.pool.HikariPool" level="ERROR"/>
<logger name="com.zaxxer.hikari.HikariDataSource" level="ERROR"/>
</configuration>
I use log4j properties, simple add these two lines:
log4j.category.com.zaxxer.hikari=INFO
log4j.logger.HikariPool=INFO
You can set the levels of Hikari loggers dynamically:
import org.apache.log4j.Logger;
import org.apache.log4j.Level;
public class App{
public static main(String[] args) {
Logger.getLogger("com.zaxxer.hikari.pool.PoolBase").setLevel(Level.OFF);
Logger.getLogger("com.zaxxer.hikari.pool.HikariPool").setLevel(Level.OFF);
Logger.getLogger("com.zaxxer.hikari.HikariDataSource").setLevel(Level.OFF);
Logger.getLogger("com.zaxxer.hikari.HikariConfig").setLevel(Level.OFF);
Logger.getLogger("com.zaxxer.hikari.util.DriverDataSource").setLevel(Level.OFF);
}
}
I have tested this on hikariCP 3.4.1 with log4j 1.2.17