We Keep Coding

Write the log in to existing common log file using slf4j

I have multiple services and each one of them interacting with each other. There is common.log file where I am writing the common log in to this file. logback.xml entry for this common.log is present in to another service lets name it as Service1. I want to write the some common things in to this existing common.log file using slf4j.
I tried to write a utility class to write the log from Service2 application to common.log and using the java.util.logging package as below ,
public class LogUtil {
private static LogUtil instance = new LogUtil();
public static LogUtil getInstance() {
return instance;
}
private static final Logger logger = Logger.getLogger(LogUtil.class.getName());
static {
try {
String logFile = System.getProperty("home") + "/logs/common.log";
FileHandler fh = new FileHandler(logFile, true);
SimpleFormatter formatter = new SimpleFormatter();
fh.setFormatter(formatter);
logger.addHandler(fh);
} catch (Exception e) {
e.printStackTrace();
}
}
public void error(String msg) {
logger.log(Level.SEVERE,"[Error Common] :"+msg);
}
}
I want to do it using the slf4j api. Please suggest me some approach to write the utility class using slf4j.

How to Override Client Side Soap Logging - Spring Boot

I'm consuming a soap webservice inside a spring boot application. The response/request logging is too big, because of one attribute which is too large. So I want to intercept that logging and remove the offending attribute.
I've been messing about with SoapEnvelopeLoggingInterceptor, but i think that is just for Server side logging. It will not get picked up.
I have configured my soap logging inside yml as follows:
logging:
pattern:
...
level:
...
org.springframework.ws.client.MessageTracing.sent: TRACE
org.springframework.ws.client.MessageTracing.received: TRACE
org.springframework.ws.server.MessageTracing: DEBUG
That works fine for logging both request and response, but I need to remove a very large problematic attribute from the envelope. Any ideas?

You can extend ClientInterceptorAdapter the abstract implementation ClientInterceptors and oveeride handleRequest and handleResponse to parse, modify and log your custom message.
The below code delegates to AbstractLoggingInterceptor handleRequest and handleResponse and overrides the logMessage to create a custom message.
Something like
public class MyInterceptor extend ClientInterceptorAdapter {
private final Logger logger = LoggerFactory.getLogger(MyInterceptor.class);
private EndpointInterceptor endpointInterceptor = new AbstractLoggingInterceptor() {
#Override
protected Source getSource(WebServiceMessage webServiceMessage) {
// Base logic same as SoapEnvelopeLoggingInterceptor getSource method.You can adjust to your preference.
if(webServiceMessage instanceof SoapMessage) {
SoapMessage soapMessage = (SoapMessage)webServiceMessage;
return soapMessage.getEnvelope().getSource();
} else {
return null;
}
}
#Override
protected void logMessage(String message) {
// You can use your regex to remove the attribute and log the message.
this.logger.debug(message);
}
};
#Override
public boolean handleRequest(MessageContext messageContext) throws WebServiceClientException {
return endpointInterceptor.handleRequest(messageContext, null);
}
#Override
public boolean handleResponse(MessageContext messageContext) throws WebServiceClientException {
return endpointInterceptor.handleResponse(messageContext, null);
}
}

There is no simple way of doing that. You ether implement your own Logger by extending sl4j API or wrap log calls and do the transformations there.
The first way will require some efforts because you'll need to implement batch of classes and make sure that the other parts of log system are not broken.
But second part is pretty strait forward.
You have ti create a logger wrapper which implements Logger interface, could be something like this:
public class LoggerWrapper extends MarkerIgnoringBase {
private final Logger logger;
public LoggerWrapper(Logger logger) {
this.logger = logger;
}
private String transformMessage(String input) {
// do all needed regexp transformations here
}
#Override
public void debug(String msg) {
String transformedMessage = transformMessage(msg);
// delegate log call to inner logger
logger.debug(transformedMessage);
}
// implement the rest of the methods here
}
And in the code you might use it like this:
private static final Logger log = new LoggerWrapper(
LoggerFactory.getLogger(SomeClass.class)
);
You can also wrap the logger without implementing Logger interface (in my case it is MarkerIgnoringBase class). In that case you'll not need to implement number of methods from the interface, however you'll louse interchangeability.
The drawback of this solution is that you have to log the messages in advance on your side (not via MessageTracing) but if it is possible I would go this way. On the other hand the first solution does it out of the box.

Need to implement Custom Logger Wrapper in log4j2

I need to have an Custom Wrapper around Log4j2. The basic requirement is that. My application should only use My CustomLogger everywhere. instead of Log4j2 logger so in future if needed i can remove 3rd party library like log4j2 etc dependency easily.
How can i do this ??

Log4j2 comes with a tool for generating custom logger wrappers:
See http://logging.apache.org/log4j/2.0/manual/customloglevels.html#CustomLoggers
This tool was intended for use with custom log levels but you can also use it for your purpose. There are a few methods you may want to remove if you want to completely remove all references to the log4j2 api, but it will still save you a lot of work.

The Log interface
First, you requires an interface to be used in each class of application. e.g.:
public interface Log {
boolean isInfoEnabled();
void info(String str);
void info(String str, Throwable t);
}
The wrapper class
Create a class that implements that interface. It's the wrapper for log4j, e.g.:
class Log4jWrapper implements Log {
private static final String FQCN = Log4jWrapper.class.getName();
private ExtendedLoggerWrapper log;
public Log4jWrapper(Class<?> clazz) {
Logger logger = LogManager.getLogger(clazz);
log = new ExtendedLoggerWrapper((ExtendedLogger) logger,
logger.getName(), logger.getMessageFactory());
}
public boolean isInfoEnabled() {
return log.isInfoEnabled();
}
public void info(String str) {
log.logIfEnabled(FQCN, Level.INFO, null, new SimpleMessage(str), null);
}
public void info(String str, Throwable t) {
log.logIfEnabled(FQCN, Level.INFO, null, new SimpleMessage(str), t);
}
}
The LogFactory class.
To create each Log, use a factory. e.g.:
public class LogFactory {
public static Log getLog(Class<?> clazz) {
return new Log4jWrapper(clazz);
}
}
Usage example
Use this factory for each instance of Log into your application. e.g.:
public class Test {
private static final Log LOG = LogFactory.getLog(Test.class);
public static void main(String[] args) {
LOG.info("This is a test... :-)");
}
}

How can we store the log4j messages to a java util list

I want to store the log4j messages to java util list and then fetch the log4j messages from the list . so how can we store the log4j messages to the list.Please help me how can we do this.

Depending on the Appender you are using you can for example create this custom Appender that appends the message regularly and also caches it in a list:
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.RollingFileAppender;
import org.apache.log4j.spi.LoggingEvent;
public class MyRollingFileAppender extends RollingFileAppender {
private List<LoggingEvent> events = new ArrayList<>();
#Override
public synchronized void doAppend(LoggingEvent event) {
events.add(event);
super.doAppend(event);
}
public synchronized List<LoggingEvent> getEvents() {
List<LoggingEvent> clone = new ArrayList<>(events);
events.clear();
return clone;
}
}
You can of course override any other Appender you wish and also log or "unlog" the message (event)

Setting up java Logger for a specific package

could anybody explain to me, how to set up java Logger for various classes from a concrete package ?
for example:
if I get this one and set it up
Logger logger = Logger.getLogger("com.google.api.client.*");
logger.setLevel(Level.CONFIG);
logger.addHandler(new Handler() {
#Override
public void close() throws SecurityException {
}
#Override
public void flush() {
}
#Override
public void publish(LogRecord record) {
// default ConsoleHandler will take care of >= INFO
if (record.getLevel().intValue() < Level.INFO.intValue()) {
System.out.println(record.getMessage());
}
}
});
there are conditions like this
Logger.getLogger(HttpTransport.class.getName()).isLoggable(Level.CONFIG);
in the library where HttpTransport is part of com.google.api.client.*
But the problem is, that
Logger.getLogger(HttpTransport.class.getName()).isLoggable(Level.CONFIG);
is false ... like if a different logger was obtained
How else should I set it for all classes from the same package? if there are conditions for loggers for concrete classes like HttpTransport.

You do not want the .* in your package string.
Change
Logger logger = Logger.getLogger("com.google.api.client.*");
to
Logger logger = Logger.getLogger("com.google.api.client");