Functional Application Logging : Code Examples Using Spring Boot and Logback

Functional Logging in
Spring Boot App
Presented By Sabir Khan

Agenda
 Functional Logging - Need
 Logging- General Overview
 Spring Boot Logging
 Start Functional Logging
 Conclusion
 References
 Thanks

Functional Logging - Need
• What I am calling functional logging is segregation of application logs based on
component functionality and not based on individual class names
• E.g. If an application can be functionally divided into two components – lets say
Indexer and Searcher then all classes that belong to Indexer should write to one log
file and all classes that belong to searcher should write to another log file
• Another example could be a system having multiple REST End points – you log based
on REST URLs and not for specific implementation classes i.e. service1 logs are
located on file1 , service2 on file2 and so on
• This simplifies production support and debugging to a great deal and makes product
easily supportable
• All classes writing to one single file and intermingling of all logs in one file is the worst
form of logging that I saw as far as production support and debugging is concerned

Functional Logging - Need
• So all in all, you are logging for a functional flow and not for individual classes and you
are not logging to a single file but scattered over multiple files
• E.g. If I have to check an Indexer issue, You will check only Indexer logs which will be
according to Indexer functional flow
• So a group of classes belonging to a particular application function flow will write to
one file and second flow will write to second and so on
• Application flow segregation should be accurate and should not be too refined or too
bulky – there has to be a balance
• Log files for an application flow will rotate as per configured log size
• Developers will have to just stop using class name as logger entity and start using a
provided logger name as logged entity for a group of classes

Logging- General Overview
• Logging in Java has been made over complicated due to over engineering
• Complications arose because there were many logging implementations coming out
• Architects and Developers were willing to try various logging APIs for various features
and performance reasons but wanted their code to be neutral to logging API change
• So there comes first level logging façade design pattern like – SLF4j (Simple Logging
Facade for Java ). I call it LEVEL-1 of abstraction with actual implementation being
LEVEL-0
• LEVEL – 0 i.e. actual implementations generally are – java.util.logging , logback and
log4j
• There are LEVEL-2 frameworks too i.e. FAÇADE of FAÇADE and I usually find them
not very useful

Logging- General Overview
• Most of applications will do just fine even with LEVEL - 0 but its better to be on
LEVEL-1 so you can change your LEVEL- 0s whenever you want if something better
comes in market
• In this presentation, I will be using SLF4j as FAÇADE and logback as implementation
• SLF4j is not an implementation of logging, its simply a façade for actual logging
implementations to simplify logging subsystems
• Another popular FAÇADE is Apache Commons Logging API

Spring Boot Logging
• Spring Boot starter POM for Web – App ( i.e. spring-boot-starter-web) already
includes spring-boot-starter-logging as dependency so you wouldn’t need any extra
dependency
• Spring Boot has a LoggingSystem abstraction that attempts to configure logging
based on contents fo classpath, giving first preference to Logback
• So for your spring-boot-starter-web application, you will get – logback-classic-*.jar,
logback-core-*.jar , jul-to-slf4j-*.jar , log4j-over-slf4j-*.jar , jcl-over-slf4j-*.jar, slf4j-api-
*.jar etc in your application
• Further Logging Levels etc can be configured using application.properties file by using
, properties like - logging.level….= ,

Start Functional Logging
• First, in your application – create a xml files, lets say logging.xml which will more or less look like
below and put it under src/main/resources
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<include resource="org/springframework/boot/logging/logback/base.xml" />
<property name="LOG_PATH" value="/var/logs" />
<appender name="Console-Appender" class="ch.qos.logback.core.ConsoleAppender">
<layout>
<pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n
</pattern>
</layout>
</appender>

Start Functional Logging…Contd
<appender name=“Function1Logs"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${LOG_PATH}/ Function1Logs.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
<fileNamePattern>${LOG_PATH}/Function1Logs.%i.log
</fileNamePattern>
<minIndex>1</minIndex>
<maxIndex>600</maxIndex>
</rollingPolicy>
<triggeringPolicy
class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<maxFileSize>5MB</maxFileSize>
</triggeringPolicy>
<encoder>
<pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n
</pattern>
<outputPatternAsHeader>true</outputPatternAsHeader>
</encoder>
</appender>

<logger name="Function1Logger" level="debug" additivity="false">
<appender-ref ref=" Function1Logs " />
</logger>
<root> <appender-ref ref="Console-Appender" /> </root>
</configuration>
-
The important thing to note in above XML is definition of logger name -
Function1Logger and that referring to - Function1Logs appender that has actual
appender configuration

- Spring Boot will automatically read your XML but if not , you can say in
application.properties that - logging.config=classpath:logging.xml
- Now at Java code level, class - org.slf4j.LoggerFactory has two getLogger(…)
methods,
public static Logger getLogger(String name) & public static Logger
getLogger(Class<?> clazz)
It’s the first version - getLogger(String name) string that helps in achieving functional
logging.

- In your Java class, you should do ,
private static final Logger logger = LoggerFactory.getLogger(“Function1Logger”);
Instead of the one with class name.
- Now at all classes, that form one flow of application function, you should use above
logger name to get Logger and use that for your logging.
- Group your application classes in appropriate number flows and add entries on
logging.xml for all such loggers and use those logger names in getting Logger
instances in your Java classes

Conclusion
- This way your logs will not be HOTCH – POTCH in one big log file or log files for
each class without connecting the classes functionally
- Developer has to still make an effort to know which logger his current class belongs
to
- So for your application, with lets say 100 classes will have like 4 -5 functionally
independent logs. Without specific logger names for each function, you either have
one log file for each class or one file for all the classes
- In non – Spring Boot Systems, you will have to just make arrangement to load that
XML file to memory in some way and add explicit dependencies manually

References
1. https://docs.spring.io/spring-boot/docs/current/reference/html/howto-logging.html
2. http://stackoverflow.com/questions/3825276/whats-the-point-of-a-logging-facade
3. https://sourcemaking.com/design_patterns/facade
4. https://www.slf4j.org/manual.html

Functional Application Logging : Code Examples Using Spring Boot and Logback

Recommended

More Related Content

What's hot (20)

Similar to Functional Application Logging : Code Examples Using Spring Boot and Logback (20)

Recently uploaded (20)

Functional Application Logging : Code Examples Using Spring Boot and Logback

Editor's Notes