How logging affect code performance?

How logging affect code performance?

By Application Development team, Cepstra Research LLP

Adding logs to code or logging requests-responses in any application has become an essential part of programming these days. Nearly every software application contains TBs of log files. Often programmers take logging for granted because of easy logging frameworks like slf4j, log4j. We hardly worry about the role of logs in our application performance.

Logging is indeed essential, but we need to keep in mind the extent of its usage. So let’s discuss how much logging is healthy for a code. Here We have created a small code exercise to identify differences in the method execution time using methods containing log and dull method execution.

We have used Google Caliper for micro benchmarking my methods and Log4J for adding logs to the code.

import com.google.caliper.Runner;
import com.google.caliper.SimpleBenchmark;
import org.apache.log4j.Logger;

public class LoggingBenchMark extends SimpleBenchmark {
    final static Logger logger = Logger.getLogger(LoggingBenchMark.class);

    public static void main(String[] args) throws Exception {
        new Runner().run(
                LoggingBenchMark.class.getName()
        );
    }

    private static final int SET_SIZE = 100000;

    public void timeWithoutLog(int reps) throws InterruptedException {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < SET_SIZE; j++) {
                try {
                    performSomething(j);
                } catch (Exception e) {
                }
            }
        }
    }


    public void timeWithPlainLog(int reps) throws InterruptedException {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < SET_SIZE; j++) {
                try {
                    logger.info("testing logs adding here");
                    performSomething(j);
                } catch (Exception e) {
                }
            }
        }
    }

    public void timeWithLogExecively(int reps) {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < 10000; j++) {
                try {
                    logger.info("testing logs adding here");
                    performSomething(j);
                } catch (Exception e) {
                    logger.error("exception in method : {}",e);
                }
                logger.debug("debug exception in method");

            }
            logger.info("some more logs");
        }
    }


    public void performSomething(int number) {
        if (number / 100 == 0) {
            throw new RuntimeException();
        }

    }
}

Just copy and run this code on your local, you will see the difference in the method execution time with log and without log is more than  2500%. With method performance, excessive logging also affects CPU usage for file I/O and the server space too.

The logging application flow is indeed necessary, but the overuse of logs to code flows has its drawbacks. Some ways of keeping logs to a minimum are by having a proper log level configured in the application, avoiding the use of calculations/fetching data in the logging statements.