Logging with multiple parameters

Question

I am currently working on a program wherein, I must write all output to a log file.

I need to write a log method, that should give an output with a level, a message, an object value, another message, an integer value, another message and another integer value, in the same order as I have specified. I can't seem to find a log method that does this. I am using Java.util.logging. Is this possible?

Isomagnetic

Consider Log4J logging.apache.org/log4j/2.x – Froemming

@verbose-mode Why? java util logging does all that is required and and is simpler to use. As far as I see it your suggestion breaks the KISS (Keep it Simple S…) principle. – Lurk

Answer 1

I assume you need the log format in the below format FINE,Message1,object.GetValue(),Message2,1,Message3,2

You need to create an output message format

logger.log(Level.INFO, "{0},{1},{2},{3},{4},{5}",new Object[]{Message1,object.getValue(),Message2,1,Message3,2});

Now you need to create a custom formatter which by extending Formatter class

public class DataFormatter extends Formatter {

@Override
public synchronized String format(LogRecord record) {
    String formattedMessage = formatMessage(record);
    String throwable = "";
    String outputFormat = "%1$s, %2$s \n %3$s"; //Also adding for logging exceptions
    if (record.getThrown() != null) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        pw.println();
        record.getThrown().printStackTrace(pw);
        pw.close();
        throwable = sw.toString();
    }
    return String.format(outputFormat,record.getLevel().getName(),formattedMessage,throwable);
}
}

Now set the newly created formatter

    for(int i=0;i<logger.getHandlers().length;i++)
        logger.getHandlers()[i].setFormatter(new DataFormatter());

Zacarias

logger.info("Logging with id {} and cache : {} " ,id,cache ); – Corruptible

This answer is correct. I have achieved the same by using java.util.logging.Logger's method public void log(Level level, String msg, Object params[]). You just need to number the placeholders in the message like {0}, {1}, etc. and pass an array of parameters like shown above new Object[] {parameter1, parameter2}. – Phytogenesis

Answer 2

We used below code while using slf4j logger -

logger.error("Error while finding A from DB. a : {} and b : {}", a, b);
logger.info("Nothing found in db for A with a : {} and b : {}", a, b);

Dori

has there anything changed, it doesnt work for me. e.g: LOGGER.info("Nothing found in db for A with a : {} and b : {}",target, file.getName()); – Eight

this works: LOGGER.log(Level.INFO,"Added file to the target: {0}", target); but not with multiple params – Eight

Question was about java.util.logging. – Devotional

Answer 3

It's a quite old topic, anyhow, my two cents, because I also prefer to use java.util.logging.Logger` in my projects where sufficient.

Lambdas make this boilerplate Formatter extension for multiple custom parameters more or less obsolete, unless you benefit from its application-wide reuse. In (my) simple scenarios, log messages are tailored to the code part where it is inserted, so String.format() is usually much easier and more flexible.

Before Java 8 and lambdas, the Formatter was the only possibility to postpone the message construction. The only alternative was, to construct the message to log in advance before the loggable check based on the Level took place.
With Java 8 lambdas, the String formatting can be postponed to after the loggable check, but still with access to the original method context. The only small downside is, that all accessed fields need to be final, due to the lambda restrictions.

Here a fairly simple snippet:

final String val1 = "lambda expression log message";
final Level level = Level.INFO;
Logger.getGlobal().log(level, () -> 
        String.format("Hello, I'm a %s, evaluated after %s loggable check.", val1, level)
);
Logger.getGlobal().log(level, new RuntimeException(), () -> 
        String.format("Hello, I'm a %s with a stack trace, evaluated after %s loggable check.", val1, level)
);

Hope this helps some of you who also want to use the built-in logging :-)

Cheers Ben

Cliff

Disadvantage of this is that parameter formatting cannot be applied when they are inserted through String.format rather than java.util.logging.Logger itself. – Tatum

Answer 4

A simple example that works for me:

Logger logger = java.util.logging.Logger.getLogger("MyLogger");
logger.log(java.util.logging.Level.INFO, "Test {0}, {1}", new Object[]{2, 3});

Result:

INFO: Test 2, 3

Fant