SpringBoot Beginner to Master (XIII) log: do not underestimate it, or suffer the loss of their own! Learn you can also design architecture

Common Logging Levels：your (honorific) --- low alignment
TRACE:
DESCRIPTION: The most detailed level of logging, typically used in the development and debugging phases to record very detailed execution information.
Example:log.trace("Entering method: {data here, followed by parameters that are automatically populated}", methodName);
DEBUG:
Description: Used for debugging information, recording the detailed execution of the program, but slightly less than the TRACE level.
Example:log.debug("Variable value: {}", variableValue);
INFO:
DESCRIPTION: Records a general information log, usually used to record the normal running status of the application.
Example:log.info("User logged in: {}", userId);
WARN:
DESCRIPTION: Warning message indicating a potential problem, but the application can continue to run.
Example:log.warn("File not found: {}", fileName);
ERROR:
DESCRIPTION: Error message indicating that an error has occurred in the application, which may affect the normal operation of the function.
Example:log.error("Database connection failed: {}", ());  Here each letter code, look carefully, there is no doubt? Special, special attention Oh, I'll tell you later
FATAL:
DESCRIPTION: Critical error, usually resulting in the application crashing or not continuing to run.
Example:log.fatal("Critical system failure: {}", ());

<dependencies>
    <!-- Spring Boot Starter Web (or any other Starter you need)-->
    <dependency>
        <groupId></groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Boot Starter Logging (with SLF4J and Logback)-->
    <dependency>
        <groupId></groupId>
        <artifactId>spring-boot-starter-logging</artifactId>
    </dependency>

    <!-- If you have already included spring-boot-starter-web, this dependency is redundant because spring-boot-starter-web already includes spring-boot-starter-logging.-->
</dependencies>

<configuration>
    <!-- Define the storage path for log files-->
    <!-- <property name="LOG_PATH" value="logs" /> relative path, where the current project is located in the directory logs, such as the project in /home/tomcat/project then logs in /home/tomcat/project/logs-->
    <!-- Customize the log path, you can specify the log save location, pointing to the Boot configuration file yml, properties file configuration-->
    <property name="LOG_PATH" value="${}" />
    <!-- Customize the log name to ignore-->
    <property name="LOG_FILE_NAME" value="application" />

    <!-- Console log output: often configured for use locally in development environments-->
    <appender name="CONSOLE" class="">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:} [%thread] %-5level [%X{uuid}] %logger{36} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- File log output: online environment test, UAT, PRE-->
    <appender name="FILE" class="">
        <!-- [Define log file requirements]-->
        <file>${LOG_PATH}/${LOG_FILE_NAME}.log</file>
        <rollingPolicy class="">
            <!-- Scroll by day
            ${LOG_PATH} path
            ${LOG_FILE_NAME} Name
            %d{yyyy-MM-dd} date
            %i Serial number, starting at 0
-->
            <fileNamePattern>${LOG_PATH}/${LOG_FILE_NAME}-%d{yyyy-MM-dd}.%</fileNamePattern>
            <!-- Maximum 500MB for a single file-->
            <maxFileSize>500MB</maxFileSize>
            <!-- Retain log files for the last 30 days-->
            <maxHistory>30</maxHistory>
            <!-- Total log file size not to exceed 1GB-->
            <!-- <totalSizeCap>1GB</totalSizeCap> -->
        </rollingPolicy>
        <!-- [Define the format of the contents of the log file in which the log is recorded]
            %d{yyyy-MM-dd HH:mm:}:
            %d: Indicates the date and time.
            {yyyy-MM-dd HH:mm:}: Formatting mode for date and time.
            yyyy: four-digit year.
            MM: two digits month.
            dd: two digits of the day.
            HH: two hours (24-hour system).
            mm: two bits of minutes.
            ss: two bits of seconds.
            SSS: three bits of milliseconds.
            [%thread]:
            %thread: indicates the name of the current thread.
            []: used to wrap the thread name to make it more readable.
            %-5level:
            %level: indicates the log level (e.g. TRACE, DEBUG, INFO, WARN, ERROR).
            -5: Indicates that the minimum width of the log level is 5 characters, if the log level is less than 5 characters, it is left justified and padded with spaces.
            %logger{36}:
            %logger: indicates the name of the logger.
            {36}: indicates that the maximum length of the logger name is 36 characters, if the name is more than 36 characters, it is truncated.
            - %msg:
            %msg: Indicates the content of the log message.
            -: used to separate the logger name from the log message to make it more readable.
            %n:
            %n: Indicates a line break character, used to break lines after each log message.
-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:} [%thread] %-5level [%X{uuid}] %logger{36} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- Asynchronous Log Output
        Role
        Improves performance:
        Asynchronous logging: AsyncAppender puts log messages into a queue and then a separate thread processes them. In this way, the main thread does not block due to logging operations, thus improving application performance.
        Reduced I/O impact: Logging often involves disk I/O operations that can be slow. With asynchronous logging, these operations can be moved to background threads, reducing the impact on the main thread.
        Resource management:
        Queue size: memory usage can be controlled by setting queueSize. A larger queue can hold more log messages, but will take up more memory.
        Discard policy: by setting discardingThreshold, you can choose whether to discard log messages when the queue is full to prevent memory overflow.
-->
    <appender name="ASYNC" class="">
        <appender-ref ref="FILE" /> <!-- Here are some pointers.-->
        <!-- This defines the size of the queue for the asynchronous logger. The queue is used to hold log messages until they are processed-->
        <queueSize>512</queueSize>
        <!-- Defines whether to discard log messages when the queue is full. The default value is 0, which means that no log messages are discarded. Greater than 0 When the number of messages in the queue exceeds this threshold, newly generated log messages are discarded-->
        <discardingThreshold>0</discardingThreshold> 
    </appender>
    
    <!-- Development log level settings springProfile enablement is associated with the pointers in the boot configuration file yml, properties-->
    <springProfile name="dev">
        <!-- Set the root level of logging to debug and specify that logs are output to the console and asynchronously to a file.-->
        <root level="debug">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="ASYNC" />
        </root>
        <!-- Specify an alternative logger for info asynchronous output to file.
            additivity="false": when log events are logged in the package, they are only output to the FILE logger and are not passed to the root logger. Therefore, these log events will not appear in the console.
            additivity="true" (default): If additivity is true, log events in the package are not only output to the FILE logger, they are also passed to the root logger and thus appear in the console.
            Scenarios
            Avoid duplicate logs: If you want log events for a particular logger to be output only to that particular logger, and don't want them to be duplicated elsewhere, set additivity="false".
            Fine-grained control of logging output: By setting additivity="false", you can control logging output more finely to ensure that log messages are clear and organized.
            Note: there is root, in fact, enough, the other top definition depends on your requirements, which is a way to refine the
-->
        <logger name= "Package name" level="info" additivity="false">
            <appender-ref ref="ASYNC" />
        </logger>
    </springProfile>
    
    <!-- test, UAT logging level settings springProfile enablement is associated with the pointers in the boot configuration file yml, properties-->
    <springProfile name="test、uat">
        <!-- Set the root level of the log to debug and specify asynchronous output to a file.-->
        <root level="debug">
            <appender-ref ref="ASYNC" />
        </root>
        <logger name= "Package name" level="info" additivity="false">
            <appender-ref ref="ASYNC" />
        </logger>
    </springProfile>

    <springProfile name="pre">
        <root level="info">
            <appender-ref ref="ASYNC" />
        </root>
        <!-- Log Level Configuration for Third-Party Libraries-->
        <logger name="" level="debug" additivity="false">
            <appender-ref ref="ASYNC" />
        </logger>
    </springProfile>
</configuration>

#
# Activate the configuration environment
=dev

# Configure where to put the log file after it's generated: the location of the file, which can be referenced after configuration
logging.file.path=/opt/tomcat/myapp/logs
# Configure the root log level
#logs=info
# Configure three-way logging levels, refine
# . Package Name=debug
# What if the log profile location, name, is customized?
#=classpath:

public class MyController {
    public void handleRequest() {
        // Generate a unique request identifier
        String uuid = ().toString();
        
        // Setting the UUID to the MDC Before you use log. Before you print the log, put the
        ("uuid", uuid);
        
        ("requesting，start:{}",json)
        // Processing requests
// ... Other business, etc., other logs, etc...
        ("responsive，end:{}",json)
        
        // Clear the UUID in the MDC after the request is processed.
        ("uuid");
    }
}

2024-11-01 14:30:00.123 [main] [f0e2c1a0-1b9d-4b7e-8c0a-123456789abc] INFO  MyController - requesting，start:{"name": "John", "age": 30}
------ If there are other logs in the business，Then theiruuidIt's all the same.，Very well positioned.  ------
2024-11-01 14:30:00.124 [main] [f0e2c1a0-1b9d-4b7e-8c0a-123456789abc] INFO  MyController - respondent，end:{"name": "John", "age": 30}

@Component // Marked as a Spring component, the SpringBoot auto-assembly mechanism automatically loads the component when it is scanned. Of course there is also the option to manually add the filter to the service (available on your own)
@Slf4j
public class RequestLoggingFilter extends OncePerRequestFilter {
    /**
     * :: Override the doFilterInternal filter method so that, for each interaction, the filter intercepts and executes the submethod
*/
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        // Generate a unique request identifier Each request generates a
        String uuid = ().toString().replaceAll("-", "");
        // Set UUIDs to the MDC, one per thread.
        ("uuid", uuid);
        // Recording the request start log
        ("Request Start，URL: {}", ());

        // Continuing the filter chain
        try {
            (request, response);
        } catch (Exception e) {
            // Recording error logs
            ("Request processing failure，URL: {}, error message: {}", (), (e));
            // Re-throw exceptions to ensure that subsequent unified exception handling can receive exceptions and handle exception messages in a unified manner
            throw e;
        } finally {
            // Recording the request closure log
            ("Request closed，URL: {}", ());
            // Clear the UUID in the MDC after the request is processed.
// ("uuid"); // explicit designation
// Clear the UUID in the MDC after the request is processed.
            (); // Clear all (MDC each request, thread has its own MDC, it is recommended to use clear all to avoid MDC context data remaining after the end of the interaction, as well as potential memory leaks or information obfuscation)
        }
    }
}

@Component
@Aspect
@Slf4j
public class ControllerAop {
    /**
     * Entry point expression: filter all control layers, and control layer interface methods
     * The first "*": any return value.
     * The second ". *": if there is one dot less, it is the next arbitrary package, and if there is one dot more, it is the next arbitrary package and sub-packages of the controller package.
     * The third ". *": any class under the controller package.
     * The fourth "*": any method
     * The fifth "(...)" : any parameter
*/
    @Pointcut("execution(public * ..*.controller..*.*(..))")
    public void privilege() {
    }

    /**
     * Define the AOP notification method: Around surrounds the controller method that satisfies the slice and will go through the level once here first.
     *
     *@param proceedingJoinPoint is an important interface in AOP (cutter-oriented programming) that is primarily used to implement wrap-around notifications (@Around)
     *@return Intercepted method execution results
     *@throws Throwable
     */
    @Around("privilege()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        // ThreadLocalContext self-defined class is a utility class for storing and passing context information in the current thread. It utilizes the ThreadLocal mechanism to ensure that each thread has a separate copy of its variables, thus avoiding data contention problems in a multi-threaded environment.
// ("aaa", "");
        // (): clears the paging information.PageHelper is a commonly used paging plugin.This method is used to clear the previous paging settings at the start of each request, ensuring that new requests are not affected by the previous paging settings.

        long start = ();
        // getSignature Get the signature information of the intercepted method, including the method name, class name, etc.
        String className = ().getDeclaringTypeName();
        String methodName = ().getName();
        Object result = null;
        // Get an array of parameters for the intercepted method
        Object[] args = ();
        for (Object object : args) {
            if(object instanceof RequestVo) {
                ("{}{}{}" , "【"+className + "." + methodName + "】" , "【Front-end and back-end interactions--requesting】" ,  null != object ? (object): object);
            }
        }
        // Continue executing the intercepted method and get the return message.
        result = ();
        long end = ();
        ("{}{}{}" , "【"+className + "." + methodName + "】" , "【Front-end and back-end interactions--responsive--take a period of (x amount of time)："+(end - start)+"】" ,  null != result ? (result) : result);
        return result;
    }
}

/**
 * :: A utility class for storing and passing contextual information in the current thread. It utilizes the ThreadLocal mechanism to ensure that each thread has a separate copy of the variable, thus avoiding data contention problems in a multi-threaded environment. ...
*/
public class ThreadLocalContext {
    
    private static final ThreadLocal<Map<String, Object>> context = new ThreadLocal<Map<String, Object>>();
    
    /**
     * :: Empty variables cached in the thread context.
*/
     public static void clear() {
       (null);
     }

     /**
      * :: Cache variables in the context of a thread.
*/
     public static void set(String key, Object value) {
       Map<String, Object> map = ();
       if (map == null) {
         map = new HashMap<>();
         (map);
       }
       (key, value);
     }

     /**
      * :: Remove variables from the thread context.
*/
     public static Object get(String key) {
       Map<String, Object> map = ();
       Object value = null;
       if (map != null) {
         value = (key);
       }
       return value;
     }

     /**
      * :: Removal of variables.
*/
     public static void remove(String key) {
       Map<String, Object> map = ();
       if (map != null) {
         (key);
       }
     }
}

2024-11-01 05:09:20.788 logback [http-nio-8080-exec-13] INFO   [ed80915251674756adf3d51c7c89bfdb] Request Start，URL: {http://......}
2023-11-01 05:09:20,789 logback [http-nio-8080-exec-13] INFO   [ed80915251674756adf3d51c7c89bfdb] -【】【Front-end and back-end interactions--requesting】{"param1":"Hello","param2":123}
2023-11-01 05:09:20,790 logback [http-nio-8080-exec-13] INFO   [ed80915251674756adf3d51c7c89bfdb] -【】【Front-end and back-end interactions--responsive--take a period of (x amount of time)：1ms】{"param1":"Hello","param2":123}
2024-11-01 05:09:20.800 logback [http-nio-8080-exec-13] INFO   [ed80915251674756adf3d51c7c89bfdb] Request closed，URL: {http://......}

try {
    // A business operation
} catch(Exception e) {
    // print exception information, useful debug, some use info, some use error (standard), but, the use of the wrong method, is not useful, only very simple information text, it is difficult to troubleshoot!
    ("debug exception message:" + ());
    ("info anomaly information:" + ());
    ("error exception message:" + e);
    /**
     * Whichever of the above, maybe it shows something like this: xxx exception message: / by zero
     * And then it's gone. You don't know what line or class is reporting the error, * or even if the getMessage is an empty string.
     * Even some errors may getMessage is an empty string, then you will only see: xxx exception message:
     * When troubleshooting, you'll have nothing to go on.
*/
    : / by zero
    at (:14)
    at (:21)
    
    // Be sure to use this, method overloading, and the overload argument is an exception object: by default log doesn't log the stack trace information for exceptions, and only overloading to pass an exception object supports exceptions showing up on the stack.
    ("Anomalous information:" , e);
    ("Anomalous information:" , e);
    ("Anomalous information:" , e);
    /**Very detailed log messages, identifying which class, which line, which location.
     * Exception message: : / by zero
     * at (:14)
     * at (:21)
     * ... Omit n lines...
*/
}

# Expose only log-related endpoints
=loggers,logfile

# Enable logfile endpoints
=true

# Configure logging levels
=INFO
=DEBUG

# Configure the log file path
logging.file.name=
logging.file.path=/var/log/myapp

{
    "levels": [
        "OFF",
        "ERROR",
        "WARN",
        "INFO",
        "DEBUG",
        "TRACE"
    ],
    "loggers": { 
        "ROOT": {
            "configuredLevel": "INFO",
            "effectiveLevel": "INFO"
        },
        "com": {
            "configuredLevel": null,
            "effectiveLevel": "INFO"
        },
        "": {
            "configuredLevel": null,
            "effectiveLevel": "INFO"
        },
        "": {
            "configuredLevel": null,
            "effectiveLevel": "INFO"
        }
        .... Omit line n here...
    }
}

@Slf4j
@RestController
@RequestMapping("api")
public class HealthExaminationController {
    // Get LoggerContext logging context object
    private LoggerContext loggerContext = (LoggerContext) ();

    /**
     * Set the logging level of the specified logger [logger name, you can query SpringBoot's monitor to turn on log monitoring. access:http://localhost:: Ports/actuator/loggers]
     *
     *@param levelName Logger name
     *@param level Log level
     *@return
     * @throws Exception
     */
    @GetMapping(value = "/levelSetting")
    public String levelSetting(@RequestParam("levelName") String levelName, @RequestParam("level") String level) {
        // Get the logger based on the specified logger name
        Logger logger = (levelName);
        if (logger == null) {
            return levelName + ": The parameter logger Name not exist!";
        }
        ("Before updating the log：Log level【{}】", ());
        // Parses the level parameter. The second parameter indicates the default value when the level parameter is illegal.
        Level newLevel = (level, null);
        if (newLevel == null) {
            return level + ": The parameter logger level is not legal!";
        }
        // Rewrite to set the level of the logger
        (newLevel);
        ("After updating the log：Log level【{}】", ());
        return "success! update logger Level to:" + ();
    }
}