第六章 日志管理

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量87 收藏
点赞数
分类专栏： spring boot 从零开始 文章标签： java log4j logback spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangzhiwei273/article/details/115935278
版权

一、使用log4j记录日志

 

新建log4j配置文件

#log4j.rootLogger=CONSOLE,info,error,DEBUG

log4j.rootLogger=info,error,CONSOLE,DEBUG

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     

log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     

log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     

log4j.logger.info=info

log4j.appender.info=org.apache.log4j.DailyRollingFileAppender

log4j.appender.info.layout=org.apache.log4j.PatternLayout     

log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  

log4j.appender.info.datePattern='.'yyyy-MM-dd

log4j.appender.info.Threshold = info   

log4j.appender.info.append=true   

#log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info

log4j.appender.info.File=/Users/dddd/Documents/testspace/pms-api-services/logs/info/api_services_info

log4j.logger.error=error  

log4j.appender.error=org.apache.log4j.DailyRollingFileAppender

log4j.appender.error.layout=org.apache.log4j.PatternLayout     

log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  

log4j.appender.error.datePattern='.'yyyy-MM-dd

log4j.appender.error.Threshold = error   

log4j.appender.error.append=true   

#log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error

log4j.appender.error.File=/Users/dddd/Documents/testspace/pms-api-services/logs/error/api_services_error

log4j.logger.DEBUG=DEBUG

log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender

log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     

log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  

log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd

log4j.appender.DEBUG.Threshold = DEBUG   

log4j.appender.DEBUG.append=true   

#log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug

log4j.appender.DEBUG.File=/Users/dddd/Documents/testspace/pms-api-services/logs/debug/api_services_debug

 

二、使用logback记录日志 

 

在resources 文件夹下，新建logback-spring.xml 文件，将文件文本内容复制进去。

<?xml version="1.0" encoding="UTF-8"?>
<configuration> <!--
 说明：
 1、日志级别及文件
 日志记录采用分级记录，级别与日志文件名相对应，不同级别的日志信息记录到不同的日志文件中
 例如：error级别记录到log_error_xxx.log或log_error.log（该文件为当前记录的日志文件），而log_error_xxx.log为归档日志，
 日志文件按日期记录，同一天内，若日志文件大小等于或大于2M，则按0、1、2...顺序分别命名
 例如log-level-2013-12-21.0.log
 其它级别的日志也是如此。
 2、文件路径
 若开发、测试用，在Eclipse中运行项目，则到Eclipse的安装路径查找logs文件夹，以相对路径../logs。
 若部署到Tomcat下，则在Tomcat下的logs文件中
 3、Appender
 FILEERROR对应error级别，文件名以log-error-xxx.log形式命名
 FILEWARN对应warn级别，文件名以log-warn-xxx.log形式命名
 FILEINFO对应info级别，文件名以log-info-xxx.log形式命名
 FILEDEBUG对应debug级别，文件名以log-debug-xxx.log形式命名
 stdout将日志信息输出到控制上，为方便开发测试使用
 -->
 <contextName>logback</contextName>
    <!--生成日志目录，dubug模式生成在项目根目录，运行jar模式生成目录在jar的同级目录-->
 <property name="LOG_PATH" value="logs" />
    <!-- 日志记录器，日期滚动记录 -->
 <appender name="FILEERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
 <file>${LOG_PATH}/log_error.log</file>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 归档的日志文件的路径，例如今天是2013-12-21日志，当前写的日志文件路径为file节点指定，可以将此文件与file指定文件路径设置为不同路径，从而将当前日志文件或归档日志文件置不同的目录。
 而2013-12-21的日志文件在由fileNamePattern指定。%d{yyyy-MM-dd}指定日期格式，%i指定索引 -->
 <fileNamePattern>${LOG_PATH}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <!-- 除按日志记录之外，还配置了日志文件不能超过2M，若超过2M，日志文件会以索引0开始，
 命名日志文件，例如log-error-2013-12-21.0.log -->
 <timeBasedFileNamingAndTriggeringPolicy
 class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>2MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--只保留最近n天的日志-->
 <maxHistory>7</maxHistory>
            <!--用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志-->
 <totalSizeCap>1GB</totalSizeCap>
            <!--启动清除超过上限的历史日志-->
 <cleanHistoryOnStart>true</cleanHistoryOnStart>
        </rollingPolicy>
        <!-- 追加方式记录日志 -->
 <append>true</append>
        <!-- 日志文件的格式 -->
 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
        <!-- 此日志文件只记录info级别的 -->
 <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>error</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!-- 日志记录器，日期滚动记录 -->
 <appender name="FILEWARN" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
 <file>${LOG_PATH}/log_warn.log</file>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 归档的日志文件的路径，例如今天是2013-12-21日志，当前写的日志文件路径为file节点指定，可以将此文件与file指定文件路径设置为不同路径，从而将当前日志文件或归档日志文件置不同的目录。
 而2013-12-21的日志文件在由fileNamePattern指定。%d{yyyy-MM-dd}指定日期格式，%i指定索引 -->
 <fileNamePattern>${LOG_PATH}/warn/log-warn-%d{yyyy-MM-dd}.%i.log
            </fileNamePattern>
            <!-- 除按日志记录之外，还配置了日志文件不能超过2M，若超过2M，日志文件会以索引0开始，
 命名日志文件，例如log-error-2013-12-21.0.log -->
 <timeBasedFileNamingAndTriggeringPolicy
 class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>2MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--只保留最近n天的日志-->
 <maxHistory>7</maxHistory>
            <!--用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志-->
 <totalSizeCap>1GB</totalSizeCap>
            <!--启动清除超过上限的历史日志-->
 <cleanHistoryOnStart>true</cleanHistoryOnStart>
        </rollingPolicy>
        <!-- 追加方式记录日志 -->
 <append>true</append>
        <!-- 日志文件的格式 -->
 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder> <!-- 此日志文件只记录info级别的 -->
 <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!-- 日志记录器，日期滚动记录 -->
 <appender name="FILEINFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
 <file>${LOG_PATH}/log_info.log</file>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 归档的日志文件的路径，例如今天是2013-12-21日志，当前写的日志文件路径为file节点指定，可以将此文件与file指定文件路径设置为不同路径，从而将当前日志文件或归档日志文件置不同的目录。
 而2013-12-21的日志文件在由fileNamePattern指定。%d{yyyy-MM-dd}指定日期格式，%i指定索引 -->
 <fileNamePattern>${LOG_PATH}/info/log-info-%d{yyyy-MM-dd}.%i.log
            </fileNamePattern>
            <!-- 除按日志记录之外，还配置了日志文件不能超过2M，若超过2M，日志文件会以索引0开始，
 命名日志文件，例如log-error-2013-12-21.0.log -->
 <timeBasedFileNamingAndTriggeringPolicy
 class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>2MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--只保留最近n天的日志-->
 <maxHistory>7</maxHistory>
            <!--用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志-->
 <totalSizeCap>1GB</totalSizeCap>
            <!--启动清除超过上限的历史日志-->
 <cleanHistoryOnStart>true</cleanHistoryOnStart>
        </rollingPolicy>
        <!-- 追加方式记录日志 -->
 <append>true</append>
        <!-- 日志文件的格式 -->
 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
        <!-- 此日志文件只记录info级别的 -->
 <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!--encoder 默认配置为PatternLayoutEncoder-->
 <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
 <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
    </appender>
    <logger name="org.springframework" level="WARN" />
    <logger name="org.hibernate" level="WARN" />
    <logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE"/>
    <logger name="org.hibernate.type.descriptor.sql.BasicExtractor" level="TRACE"/>
    <logger name="org.hibernate.SQL" level="DEBUG"/>
    <logger name="org.hibernate.engine.QueryParameters" level="DEBUG"/>
    <logger name="org.hibernate.engine.query.HQLQueryPlan" level="DEBUG"/>
    <!-- 生产环境下，将此级别配置为适合的级别，以免日志文件太多或影响程序性能 -->
 <root level="INFO">
        <appender-ref ref="FILEERROR" />
        <appender-ref ref="FILEWARN" />
        <appender-ref ref="FILEINFO" />
        <!-- 生产环境将请stdout,testfile去掉 -->
 <appender-ref ref="STDOUT" />
    </root>
</configuration>

三、使用AOP统一处理Web请求日志。

 

POM文件新增依赖

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-aop</artifactId>

</dependency>

切面拦截器，增加日志记录内容。

@Aspect

@Component

public class WebLogAspect {

private Logger logger = LoggerFactory.getLogger(getClass());

@Pointcut("execution(public * com.itmayiedu.controller..*.*(..))")

public void webLog() {

}

@Before("webLog()")

public void doBefore(JoinPoint joinPoint) throws Throwable {

// 接收到请求，记录请求内容

ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

HttpServletRequest request = attributes.getRequest();

// 记录下请求内容

logger.info("URL : " + request.getRequestURL().toString());

logger.info("HTTP_METHOD : " + request.getMethod());

logger.info("IP : " + request.getRemoteAddr());

Enumeration<String> enu = request.getParameterNames();

while (enu.hasMoreElements()) {

String name = (String) enu.nextElement();

logger.info("name:{},value:{}", name, request.getParameter(name));

}

}

@AfterReturning(returning = "ret", pointcut = "webLog()")

public void doAfterReturning(Object ret) throws Throwable {

// 处理完请求，返回内容

logger.info("RESPONSE : " + ret);

}

}

四、记录每个接口的响应时间。

 记录每个接口的响应时间，在实际使用中可以用来查询接口的运行效率。也可以通过elk的方式，将接口的响应的响应效率通过es等工具进行展示，监控接口的运行情况。

 

ElkFormatLog 类
//ELK日志记录实体类
public class ElkFormatLog {

    //接口名称
 public String interfacename;
    //日志级别，info信息，errinfo，错误信息
 public String logLevel;
    //日志记录时间
 public String logTime;
    //访问者Ip
 public String Ip ;
    //服务端Ip
 public String serverIp ;
    //服务端计算机名称
 public String servercomputername ;
    //调用的接口路径
 public String function ;
    //执行开始时间
 public String starttime;
    //执行结束时间，接口返回时间
 public String endtime;
    //接口方式执行耗时
 public long usetime;
    //接口入参
 public String inputParameters;
    //接口出参
 public String outputParameters;
    //接口信息，出错记录错误信息
 public String messageinfo;

}

 

切面拦截器优化

package com.winning.sx.microframework.config;

import com.alibaba.fastjson.JSON;
import com.winning.sx.microframework.common.constant.BaseConstant;
import com.winning.sx.microframework.common.util.ElkFormatLog;
import com.winning.sx.microframework.common.util.LogInfo;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.joda.time.DateTime;
import org.joda.time.Days;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
使用记录ELK日志
 */
@Aspect
@Slf4j
@Component
public class AccessLogAspect {

    @Pointcut("execution(public * com.winning..controller.*.*(..))")
    public void accessLog() {
    }

    @Around("accessLog()")
    public Object around(ProceedingJoinPoint joinPoint){
        DateTime startTime =DateTime.now();
        // 定义返回对象、得到方法需要的参数
 Object resultData = null;
        Object[] args = joinPoint.getArgs();
        String uri = "";
        String methodName = joinPoint.getSignature().getName();
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        try {
            uri = request.getServletPath();
            if (joinPoint != null && joinPoint.getArgs() != null) {
                StringBuffer buf = new StringBuffer("[");
                for (int i = 0; i < joinPoint.getArgs().length; i++) {
                    Object arg = joinPoint.getArgs()[i];
                    if (arg != null && !(arg instanceof ServletRequest) && !(arg instanceof ServletResponse)) {
                        String argStr = arg.toString();
                        //针对登录密码日志，做特殊处理
 if (argStr.contains("password") && argStr.contains("LoginForm")){
                            int pwIndex = argStr.indexOf("password=");
                            argStr = argStr.substring(0,pwIndex+10)+"****"+argStr.substring(argStr.indexOf("'",pwIndex+11));
                        }
                        buf.append(argStr);
                    }
                }
// log.info("args{}", buf.append("]").toString());
 }
            resultData = joinPoint.proceed(args);
            DateTime endTime = DateTime.now();
            long diff = endTime.getMillis() - startTime.getMillis();
            //log.info("======>用户：{},完成请求[{}],开始时间:{},结束时间:{},耗时:{},返回:{}", "", uri,startTime.toString(),endTime.toString(), diff, resultData.toString());
 ElkFormatLog elk = new ElkFormatLog();
            elk.interfacename="JAVAVue系统框架";
            elk.logLevel = "loginfo";
            Date date = new Date();
            SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
            elk.logTime = sd.format(date);
            elk.Ip = request.getRemoteAddr();
            elk.serverIp = request.getLocalAddr();
            elk.servercomputername =request.getLocalName();
            elk.function = request.getRequestURL().toString();
            elk.starttime = startTime.toString("yyyy-MM-dd HH:mm:ss.SSS");
            elk.endtime = endTime.toString("yyyy-MM-dd HH:mm:ss.SSS");
            elk.usetime = diff;
            elk.inputParameters = request.getQueryString();
            elk.outputParameters = JSON.toJSONString(resultData);
            elk.messageinfo = "";
            // 记录ELK日志信息
 LogInfo.writeLog(elk);
        } catch (Throwable e) {
            e.printStackTrace();
            DateTime endTime = DateTime.now();
            long diff = endTime.getMillis() - startTime.getMillis();
            ElkFormatLog elk = new ElkFormatLog();
            elk.interfacename="JAVA系统框架";
            elk.logLevel = "errinfo";
            Date date = new Date();
            SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
            elk.logTime = sd.format(date);
            elk.Ip = request.getRemoteAddr();
            elk.serverIp = request.getLocalAddr();
            elk.servercomputername =request.getLocalName();
            elk.function = request.getRequestURL().toString();
            elk.starttime = startTime.toString("yyyy-MM-dd HH:mm:ss.SSS");
            elk.endtime = DateTime.now().toString("yyyy-MM-dd HH:mm:ss.SSS");
            elk.usetime = diff;
            elk.inputParameters = request.getQueryString();
            elk.outputParameters = JSON.toJSONString(BaseConstant.ERR_MSG);
            elk.messageinfo = e.toString();
            // 记录异常信息
 LogInfo.writeLog(elk);
            //log.error("======>用户：{},完成请求[{}],开始时间:{},结束时间:{},耗时:{},返回:{}", "", uri,startTime.toString(),endTime.toString(), diff, resultData.toString());
// log.error("======>请求[{}]异常！耗时:{}", uri, (endTime - startTime));
 }
        return resultData;
    }
}

 

记录日志类

package com.winning.sx.microframework.common.util;

import com.alibaba.fastjson.JSON;
import com.winning.sx.microframework.common.util.ElkFormatLog;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
记录ELK可分析接口日志，方便问题追踪
 */
public class LogInfo {

    /**
 * 将信息写入到日志
 *
 * @param
 * @return
 * @throws IOException
 */
 public static boolean writeLog(ElkFormatLog elk) {
        //先进行日志内容拼接
 String content = info(elk);
        //创建文件夹及日志文件，每天一个文件夹，1小时一个日志文件
 Date date = new Date();
        SimpleDateFormat dtnow = new SimpleDateFormat("yyyyMMdd");
        SimpleDateFormat dtnowhour = new SimpleDateFormat("HH");
        String logfilepath = dtnow.format(date);
        String logfiel = dtnowhour.format(date);
        File file1 = new File(System.getProperty("user.dir") + "/WinningLog");
        //如果文件夹不存在则创建
 if (!file1.exists() && !file1.isDirectory()) {
            file1.mkdir();
        }
        File file = new File(System.getProperty("user.dir") + "/WinningLog/" + logfilepath);
        //如果文件夹不存在则创建
 if (!file.exists() && !file.isDirectory()) {
            file.mkdir();
        }
        File fileName = new File(System.getProperty("user.dir") + "/WinningLog/" + logfilepath + "/" + logfiel + ".wnlog");
        RandomAccessFile mm = null;
        boolean flag = false;
        FileOutputStream o = null;
        try {
            o = new FileOutputStream(fileName, true);
            o.write(content.getBytes("utf-8"));
            o.close();
            flag = true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (mm != null) {
                try {
                    mm.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        try {
            //使用线程进行删除过期的日志文件
 MyThread myThread = new MyThread();
            Thread t1 = new Thread(myThread);
            t1.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /*
 使用线程进行删除过期日志文件，保留2天
 */
 public static class MyThread extends Thread {
        public void run() {
            removeOldFile(System.getProperty("user.dir") + "/WinningLog/", 2);
        }
    }

    /*
 拼接日志消息
 */
 private static String info(ElkFormatLog elk) {

        StringBuffer buffer = new StringBuffer();
        buffer.append(JSON.toJSONString(elk) + "\r\n");
        return buffer.toString();
    }

    private static void removeOldFile(String filepath, int keepDays) {
        File file = new File(filepath);
        File[] filelist = file.listFiles();
        for (int i = 0; i < filelist.length; i++) {
            File filedetail = new File(filelist[i].getPath());
            File[] filedetaillist = filedetail.listFiles();
            for (int j = 0; j < filedetaillist.length; j++) {
                long newtime = System.currentTimeMillis();
                long txttime = filedetaillist[j].lastModified();
                long time = newtime - txttime;
                time=time / (1000 * 60 * 60 * 24);
                if (time >= keepDays) {
                    filedetaillist[j].delete();
                }
            }
            //最后删除空文件夹
 filedetaillist = filedetail.listFiles();
            if(filedetaillist.length==0) {
                filelist[i].delete();
            }
        }
    }
}

五、将日志信息信息存储到数据库表中。

 代码优化

六、关于接口日志的细节思考。

 

1、接口必须进行日志存储，否则无法排查问题和处理问题。

2、接口日志一般建议保存7-30天，再长占用空间过多。

3、接口一定要进行性能分析，即存储服务的响应时间进行分析。

4、服务如果文件存储，建议按照小时存储，将一天的日志文件按照一个小时或者半个小时进行存储，方便排查问题。

 

1、日志存储在数据库还是通过文件格式存储。 

存储在数据库的优势在于方便进行结构化查询和分析。

缺陷在于需要对于日志进行定时清理，要不然数据库日志越来越大。

2、使用elk的方案。

将日志通过文件json格式进行存储，再异步进行文件提出，抽取到日志分析的数据库进行分析。因为是异步的即使日志平台崩溃了也不影响正常业务的使用。

阳仔蛋炒饭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习笔记：日志的分类以及LogCenter
TKE_yinian的博客
02-27 2255
网络设备在运行过程中输出的信息称为日志，实时了解网络中各种业务的运行状态，掌握网络设备上各个功能模块的运行情况。 • 防火墙支持输出如下日志： 会话日志： o 报文经过防火墙处理后将会在防火墙上建立会话。防火墙支持会话信息的输出，管理员可以根据实际需要，选择在会话老化后输出、新建会话时输出、或者定期输出会话信息。 丢包日志： o 报文被防火墙丢弃后，防火墙支持将报文的信息以及被丢弃的原因输出。报文...
ELKB日志流：日志分类思路
wx940627的博客
06-17 1257
目录0、引言1、分类思路1.1 日志类型1.2 日志内容 0、引言 日志已经可以收集了，那总不能将所有的日志都放在一个索引下吧？ 那怎么对日志进行分类呢？ 1、分类思路 我的分类思路主要是两个层级：日志类型、日志内容； 1.1 日志类型 将不同类型的日志保存到对应ES的索引中； 比如：nginx访问日志 ， mysql错误日志， app业务日志等； 命名方式 ：nginx-access-20200101； 日志的收集有两种方式：Filebeat推送，Redis队列； Filebeat推送（主要负责系统日
Log4j2不同级别的日志写入到不同文件+扩展日志级别实现业务日志分类
三生三石光润木子
11-26 3699
目录 前言 1.不同级别的日志输出到不同的文件 1.1 自定义RollingFile配置 1.2 自定义Console 1.3 Async异步输出 1.4 自定义Logger配置 1.5 自定义统一日志类LogUtil.java 1.6 使用说明 1.6.1.1 通过LogUtil创建业务类日志对象 1.6.1.2 使用业务类日志对象 1.7 日志输出样式 2.扩展日志级别 2.1 自定义日志级别 2.2 自定义Rolling...
springboot使用logback-spring.xml配置讲解
热门推荐
heguiliang_123的博客
05-13 1万+
springboot按照profile进行打印日志log4j logback slf4j区别？首先谈到日志,我们可能听过log4j logback slf4j这三个名词，那么它们之间的关系是怎么样的呢？SLF4J，即简单日志门面（Simple Logging Facade for JAVA），不是具体的日志解决方案，它只服务于各种各样的日志系统。一般来说，slf4j配合log4j、logback进...
SpringBoot学习笔记四：log日志的使用
mjjyszazc的博客
12-29 863
一、spring boot的默认日志系统 spring boot使用log back作为默认的日志系统。log back的引入在搭建springboot框架引入 spring-boot-starter时就已经完成了。因此当项目中没有任何log有关的配置文件以及配置项，并且也没有在pom文件中额外引入任何log有关的依赖时，运行起来是这样的： 即从info级别开始输出，并且此时不会有日志文件生成。...
第六章 布局管理
Twinkle
10-24 525
在Qt Designer中使用会比代码中方便，但是代码中的布局会比较灵活。使用Qt布局类的一个重要原因是：他可以确保窗体能够自动适应不同的字体、语言、和系统平台。     主要类有QHBoxLayout、QVBoxLayout、QGridLayout和QStackLayout。可执行布局管理的类还有QSplitterr、QScrollArea、QMainWindow和QMidArea。 一、在
第16章MySQL日志管理.docx
06-11
MySQL日志管理是数据库系统维护和故障排查的重要组成部分。它主要涉及两大类日志：一类是二进制日志（Binary Log），另一类是错误日志（Error Log）。此外，还包括通用查询日志（General Query Log）和慢查询日志...
XX数据库实践教程6第六章自动化管理任务.ppt
11-21
【XX数据库实践教程6第六章自动化管理任务】深入解析 自动化管理任务是数据库管理系统中一项重要的功能，旨在提高效率，减少人为错误，并确保数据库的稳定运行。本章将重点介绍自动化管理任务的基本概念、分类、...
第10章数据库存储管理与数据恢复.ppt
11-23
在创建数据库时，我们还可以指定文件组，如在示例10-6中创建的MyDB数据库，包含一个主数据文件、一个用户定义文件组和一个日志文件。文件组的使用使得数据管理更为灵活，可以根据业务需求动态调整。 总的来说，...
第15章 MySQL日志PPT
01-03
6. **日志管理** - **日志轮换**：定期重命名和创建新的日志文件，避免单个日志文件过大。 - **清理策略**：根据业务需求设定日志保留时间，避免无限制增长。 了解并合理利用MySQL的日志系统，对于数据库的运维、...
第6章 文件和目录管理1
08-03
【第6章 文件和目录管理1】 在操作系统中，文件和目录管理是日常操作的核心环节。本章聚焦于Linux环境下的文件系统管理，包括文件系统的结构、权限管理和具体操作。Linux文件系统是基于File System Hierarchy ...
LogBack——LogBack在项目（Web或Java）中的应用
学习，学习是一种代表你未来的能力！
12-21 7911
初始介绍LogBack，详细介绍RollingFileAppender及其在项目中的使用情况，实现了基于按日期、大小的日志滚动策略和分级别写日志文件，并提供LogBack的配置文件。
ELK系列(2) - Kibana怎么修改日期格式Date format
weixin_30457465的博客
05-12 658
问题 Kibana在创建Index Patterns的时候，可以选择某个date类型的field作为排序字段。之后在Discover里打开对应的index，会发现这个date类型的field的格式显示如下： April 10th 2019, 17:40:32.359 这是Kibana默认的日期格式，有两种修改的方式。 方式一：全局修改 登录http://localhost:5601/，会...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1082
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 763
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 739
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1297
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
Oracle DBA：两天速成课程第六章——数据库存储结构管理
“Oracle DBA 两日速成课程6”主要涵盖了如何使用Oracle Enterprise Manager（企业管理器）来管理和查看数据库的存储结构，包括查看数据库存储结构、创建新表空间、修改表空间、回收表空间空间、复用重做日志以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值