---
# System prepended metadata

title: Automatic Logging Framework

---

Automatic Logging Framework
===


1. [Build](##build)
2. [Steps to use the TesterApp](#steps)
3. [Runtime Simulation](#runtime-simulation)
4. [Using the framework](#using-framework)
5. [Contributors](#contributors)

## Build <a name="build"></a>

This AOP framework makes use of the Maven build tool to create, compile and run the code written in the JAVA language.

ALF-red framework can be incorporated in  all Java applications built using the Spring framework and its extensions like Spring boot. 

Inorder test the framework we have created two seperate projects -  
1) **ALF-red** (The framework itself)   
2) **TesterApp** (Any spring based Java application making use of the ALF-red logging framework)

#### IDE's
We have made use of the IntelliJ IDEA for development purpose.
##### IntelliJ IDEA

Steps to build ALF-red :

Since it uses the maven dependency management tool, run the following commands to build the framework on IntelliJ  IDEA

1. Import the project from version control
2. Execute the following maven goal in the project (This will also run the unit tests of the application)

 ``` 
mvn clean install test
```
3. This builds a 0.0.1-SNAPSHOT version jar of ALF-red framework. This will add the jar in the target folder and also adds a dependency in the .m2 repository folder.

## Steps to use the TesterApp <a name="steps"></a>

1. Import the project from version control
2. There are three options to run the application

    OPTION 1.
    
    Execute the following maven goal in the project

    ```mvn
    mvn clean install
    ```
    This will create a jar in the target folder.

    Execute the following command in the target folder from CLI to run the jar.
    
    ```
    java -jar .\TesterApp-0.0.1-SNAPSHOT.jar
    ```
    
    OPTION 2. 
    
    Run the following command from CLI.
    
    ```mvn
    mvn spring-boot:run
    ```

    OPTION 3.
    
    Run the application from IntelliJ from the main class.


<!-- ## Building artifact on IntelliJ

The alfred.jar provided in the repository can be added as an external dependency for TesterApp 
OR
Building alfred.jar manually to use in TesterApp
1. `Project Structure -> Artifacts -> Jar -> From modules with dependencies`
2. `Build -> Build Artifact`
3. `This creates a jar file alfred.jar`
4. `alfred.jar can be added as an external dependency to the TesterApp`
 -->

<!-- ### Adding external dependency to IntelliJ

`File -> Project Structure -> Modules -> (Add the jar file)` -->



## Runtime Simulation <a name="runtime-simulation"></a>

Testing the framework using TesterApp. The ALF_red framework is added as a dependency to the TesterApp.

Sample Requests which generates appropriate logs on Windows.
    
GET request 

```
curl -X GET localhost:7002/v1/user/John -H "header: application/json" 
```


POST request

```
curl -X POST localhost:7002/v1/user/John/submit -H "header: application/json" -H "Content-Type: application/json" -d "{ \"name\": \"John\",\"ssn\":123456789}"
```

PUT request

```
curl -X PUT localhost:7002/v1/user/Shawn/update -H "header: application/json" -H "Content-Type: application/json" -d "{ \"name\": \"Shawn\",\"ssn\":234567891}"
```

DELETE request

```
curl -X DELETE localhost:7002/v1/user/John
```

Exception endpoint

```
curl -X GET localhost:7002/v1/user/123/exception -H "header: application/json" -H "Content-Type: application/json" 
```


For test purpose, if incorrect "name" values are provided for any of the above 4 requests, e.g a number is provided for the "name" field then it will return this exception - "Name cannot have a number"

#### Logs 
It creates a logs folder in the root directory with 3 kinds of log files:
1. Event
2. Exception
3. Health 

All logs created are in the standard JSON format with a unique identifier that connects related logs.      
### Running unit tests
```
mvn clean test
```
## Using the framework <a name="using-framework"></a>


1. Can work with any application using spring boot and Java 8+
2. The application must follow spring boot naming conventions. **Controller** and **Interface**.
3. Every bean the needs loggings should have an interface except the Controller
4. After building the ALF-red app with maven add the dependancy
```xml
<dependency>
    <groupId>com.example</groupId>
    <artifactId>alfred</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
```
6. To use ALF-red the application must import the AlfredConfiguration class. The import can be in the main class.
```java=
@Import(AlfredConfiguration.class)
```
8. The developer can specify two properties in the application.properties file and set to either true or false.
- alfred.event = true (default : alfred.event = false) enables debug logging for all methods.
- alfred.health = true (default : alfred.health = false) enables health logging for the application.
9. Recommended setting for deployment:
- alfread.event = false
- alfread.health = true




## Contributors <a name="contributors"></a>
1. Akshay Narula 
2. Glady Dennyson Thomas `(Team Leader)`
3. Jay Garg 


