拦截error日志，并发送到钉钉群

最新推荐文章于 2022-11-15 13:40:04 发布
最新推荐文章于 2022-11-15 13:40:04 发布
阅读量3k 收藏 1
点赞数 1
分类专栏： 【Java】 # 【工具】
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/jiadajing267/article/details/95054001
版权
本文介绍如何通过自定义Logback Appender拦截error级别日志，结合SpringBoot全局异常处理，将异常详情及请求参数推送至钉钉，提升问题定位效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

       之前公司的错误日志都发送到邮箱中，但是邮箱存在响应延迟，造成问题解决不及时，结合我们正在使用的通信方式，发送到钉钉中效果会更好些。

       一般上，在开发过程中，像log4j2、logback日志框架都提供了很多Appender，基本上可以满足大部分的业务需求了。但在一些特殊需求可以自定义Appender。本文主讲利用自定义Appender拦截error级别日志以及springboot的全局异常拦截，并且记录异常的请求参数，全部推送到钉钉群中，研发只需要根据钉钉群异常详情可以轻松定位问题内容。

    利用观察者模式，实现多个监听者可以同时接受到相同的错误信息，例如需要将异常体现在邮箱和钉钉中，本文主要讲错误信息推送到钉钉中。

自定义Appender

import ch.qos.logback.classic.spi.LoggingEvent;
import ch.qos.logback.core.AppenderBase;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class SyncCallbackAppender extends AppenderBase<LoggingEvent> {
    private static List<SyncCallbackAppender.OnAppendListener> onAppendListeners = new ArrayList();

    public SyncCallbackAppender() {
    }

    protected void append(LoggingEvent eventObject) {
        onAppendListeners.forEach((item) -> {
            item.onAppend(eventObject);
        });
    }

    public static void addAppendListenr(SyncCallbackAppender.OnAppendListener listener) {
        if (listener != null && !onAppendListeners.contains(listener)) {
            onAppendListeners.add(listener);
        }

    }

    public interface OnAppendListener {
        void onAppend(LoggingEvent var1);
    }
}

利用springmvc注解@ControllerAdvice，实现请求参数的全局预处理，拦截请求参数当发生异常时同样将请求参数输出到钉钉中

/**
 * @version 1.0
 * @title 获取请求参数信息
 * @description
 * @changeRecord
 */
@ControllerAdvice
public class RequestInfoAdvice implements RequestBodyAdvice {
    private ThreadLocal<String> jsonRequestBody = new ThreadLocal<>();

    @Override
    public boolean supports(MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }

    @Override
    public Object handleEmptyBody(Object object, HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
        return object;
    }

    /**
     * 获取原始的请求参数（json格式的）
     *
     * @param httpInputMessage
     * @param methodParameter
     * @param type
     * @param aClass
     * @return
     * @throws IOException
     */
    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) throws IOException {
        String contentType = RequestData.getRequest().getContentType();
        if (contentType != null && "application/json".equalsIgnoreCase(contentType)) {
            jsonRequestBody.set(null);
            if (httpInputMessage != null && httpInputMessage.getBody() != null) {
                byte[] bodyBytes = IOUtils.toByteArray(httpInputMessage.getBody());
                jsonRequestBody.set(new String(bodyBytes));
                return new HttpInputMessage() {
                    @Override
                    public HttpHeaders getHeaders() {
                        return httpInputMessage.getHeaders();
                    }
                    @Override
                    public InputStream getBody() {
                        return new ByteArrayInputStream(bodyBytes);
                    }
                };
            }
        }
        return httpInputMessage;
    }

    @Override
    public Object afterBodyRead(Object object, HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
        return object;
    }

    /**
     * 获取请求信息
     *
     * @return
     */
    public String getRequestInfo() {
        StringBuffer stringBuffer = new StringBuffer("");
        HttpServletRequest req = RequestData.getRequest();
        if (req == null) {
            return "";
        }
        //获取请求方式
        stringBuffer.append("\n");
        stringBuffer.append("请求方式: " + req.getMethod());
        stringBuffer.append("\n");
        //获取完整请求路径
        stringBuffer.append("请求地址: " + req.getRequestURL());
        stringBuffer.append("\n");
        //获取请求参数
        stringBuffer.append("请求参数: " + getRequestParam(req));
        //获取ip来源
        stringBuffer.append("\n");
        stringBuffer.append("IP来源: " + IpUtil.getUserIPString(req));
        stringBuffer.append("\n");
        stringBuffer.append("\n");
        Enumeration<String> headerNames = req.getHeaderNames();
        //获取获取的消息头名称，获取对应的值，并输出
        while (headerNames.hasMoreElements()) {
            String nextElement = headerNames.nextElement();
            stringBuffer.append(nextElement + ":" + req.getHeader(nextElement));
            stringBuffer.append("\n");
        }
        stringBuffer.append("\n");
        return stringBuffer.toString();
    }

    /**
     * 获取请求参数
     *
     * @param request
     * @return
     */
    public String getRequestParam(HttpServletRequest request) {
        StringBuilder stringBuilder = new StringBuilder();
        try {
            if ("get".equalsIgnoreCase(request.getMethod())) {
                stringBuilder.append(request.getQueryString());
            } else if ("post".equalsIgnoreCase(request.getMethod())) {
                String contentType = RequestData.getRequest().getContentType();
                if (contentType != null && "application/json".equalsIgnoreCase(contentType)) {
                    String jsonParm = jsonRequestBody.get();
                    if (StringUtil.isNotEmpty(jsonParm)) {
                        try {
                            //格式化输出
                            return JSON.toJSONString(JSONObject.parse(jsonRequestBody.get()),
                                    SerializerFeature.PrettyFormat, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteDateUseDateFormat);
                        } catch (Exception ex) {
                            return jsonParm;
                        }
                    }
                } else if (request.getParameterNames() != null) {
                    Enumeration<String> enumeration = request.getParameterNames();
                    while (enumeration.hasMoreElements()) {
                        String name = enumeration.nextElement();
                        String[] values = request.getParameterValues(name);
                        for (int i = 0; i < values.length; i++) {
                            String value = values[i];
                            stringBuilder.append(name);
                            stringBuilder.append("=");
                            stringBuilder.append(value);
                            if (i < values.length - 1) {
                                stringBuilder.append("&");
                            }
                        }
                        if (enumeration.hasMoreElements()) {
                            stringBuilder.append("&");
                        }
                    }
                    return URLDecoder.decode(stringBuilder.toString(), "utf-8");
                }
            }
            return stringBuilder.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }
}

根据拦截的error日志处理堆栈信息，发送到钉钉群中


/**
 * @version 1.0
 * @title 把异常信息发送到钉钉报警群
 * @description
 * @changeRecord
 */
@Service
public class ErrorToDingtalkService implements SyncCallbackAppender.OnAppendListener {

    /**
     * 获取相关请求参数
     */
    @Resource
    private RequestInfoAdvice requestInfoAdvice;
    /**
     * 钉钉通知类
     */
    @Resource
    private DingTalkAlarm dingTalkError;
    /**
     * 将异常信息缓存到redis中
     */
    @Resource
    private ICacheOperation cacheOperation;

    public ErrorToDingtalkService() {
        //注册接收日志需要被通知的通知者
        SyncCallbackAppender.addAppendListenr(this);
    }

    @Override
    public void onAppend(LoggingEvent eventObject) {
        try {
            handLoggingEvent(eventObject);
        } catch (Throwable throwable) {

        }
    }


    /**
     * 钉钉报警详情
     * 记录上次发送时间以及出现次数
     */
    @Data
    static class ReportDetail implements Serializable {
        private String lastSendTime;//最近一次发送时间
        private long count;//出错次数
    }

    /**
     * 处理业务异常转发到钉钉群
     */
    public void handleException(Throwable throwable) {
        try {
            reportToDingTalk(throwable.getStackTrace(), throwable.getClass().getName(), getSimpleDescribe(throwable));
        } catch (Throwable throwable1) {

        }
    }


    /**
     * 把ERROR级别的log转发到钉钉群
     *
     * @param eventObject
     */
    private void handLoggingEvent(LoggingEvent eventObject) {
        if (eventObject.getLevel() != Level.ERROR || "emailLogger".equals(eventObject.getLoggerName())) {
            return;
        }
        String msg;
        try {
            msg = eventObject.getFormattedMessage();
        } catch (Throwable throwable) {
            msg = eventObject.getMessage();
        }
        String className = "";
        if (eventObject.getThrowableProxy() != null) {
            msg = msg + "," + eventObject.getThrowableProxy().getMessage();
            className = eventObject.getThrowableProxy().getClassName();
        }
        reportToDingTalk(eventObject.getCallerData(), className, msg);
    }


    /**
     * @param stackTraceElements 上下文堆栈
     * @param className          异常类型
     * @param message            异常描述
     * @return
     */
    private void reportToDingTalk(StackTraceElement[] stackTraceElements, String className, String message) {
        if (stackTraceElements == null || stackTraceElements.length == 0) {
            return;
        }
        String msg = "service_error_md5_" + stackTraceElements[0].toString() + "_" + stackTraceElements.length;
        String errorMd5 = Md5Util.md5(msg);
        ReportDetail detail = cacheOperation.load(errorMd5);
        if (detail == null) {
            detail = new ReportDetail();
            detail.setCount(0);
            detail.setLastSendTime(DateUtil.dateTime2String(LocalDateTime.now()));
        }
        try {
            java.time.Duration duration = java.time.Duration.between(DateUtil.string2DateTime(detail.getLastSendTime()), LocalDateTime.now());
            detail.setCount(detail.getCount() + 1);
            //不是首次出现异常或者距离上次发送少于1分钟 ,利用配置中心Apollo，实现动态配置相同异常出现间隔
            Config dingtalk = ConfigService.getConfig("dingtalk");
            Integer reportInterval = dingtalk.getIntProperty("reportInterval", 60);
            if (detail.getCount() > 1 && duration.toMillis() < reportInterval * 1000) {
                return;
            } else {
                TokenUser user = RequestData.getTokenUser();
                HttpServletRequest httpServletRequest = RequestData.getRequest();
                StringBuffer stringBuffer = new StringBuffer();
                stringBuffer.append("\n发送时间: " + DateUtil.dateTime2String(LocalDateTime.now()));
                stringBuffer.append("\n请求编号: ");
                stringBuffer.append(RequestData.getRequestId());
                stringBuffer.append("\n主机名称: ");
                stringBuffer.append(IpUtil.getHostName());
                stringBuffer.append("\n城市编码: ");
                stringBuffer.append(user == null ? "未知" : user.getAreaCode());
                stringBuffer.append("\n操作人员: ");
                stringBuffer.append(user == null ? "未知" : user.getUserName() + "(" + user.getUserId() + ")");
                if (httpServletRequest != null) {
                    stringBuffer.append("\n异常路径: ");
                    stringBuffer.append(httpServletRequest.getRequestURI());
                }
                stringBuffer.append("\n异常预览: ");
                if (StringUtil.isNotEmpty(className)) {
                    stringBuffer.append("\n>" + className);
                }
                stringBuffer.append("\n>" + message);
                stringBuffer.append("\n\n[查看详情]");
                String errorId = RequestData.getRequestId();
                if (StringUtil.isEmpty(errorId) || "unknown-requestId".equals(errorId)) {
                    errorId = BusinessIdUtil.generateBizId();
                }
                cacheOperation.save(errorId, requestInfoAdvice.getRequestInfo() + "\n" + message + "\n" + stackTraceElementToString(stackTraceElements), 3600 * 24 * 3);
                String detailUrl = "https://****.com/call/api/debug/errorDetail?errorId=" + errorId;
                if (StringUtil.isNotEmpty(Util.runEvn) && !"master".equals(Util.runEvn) ) {
                    detailUrl = "https://" + Util.runEvn + "-**.com/call/api/debug/errorDetail?errorId=" + errorId;
                } 
                //开发本机调试
                if (DeveloperUtil.isLocalDebug()) {
                    detailUrl = "http://localhost:8065/**/errorDetail?errorId=" + errorId;
                }
                stringBuffer.append("(" + detailUrl + ")");
                if (detail.getCount() > 1) {
                    stringBuffer.append("\n###### <font color=#ff0000>");
                    stringBuffer.append(formatDateTime(DateUtil.string2DateTime(detail.getLastSendTime())));
                    stringBuffer.append("也出现过,");
                    stringBuffer.append(" 共出现了" + detail.getCount() + "次");
                    stringBuffer.append("</font>");
                }
                boolean result = dingTalkError.sendMarkDownMsg(stringBuffer.toString().replace("\n", "\n\n"), null);
                //记录最后出现次数
                if (result) {
                    detail.setLastSendTime(DateUtil.dateTime2String(LocalDateTime.now()));
                }
            }
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        } finally {
            try {
                //缓存异常的堆栈信息
                cacheOperation.save(errorMd5, detail);
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
        }

    }
    /**
     * 堆栈信息转成字符串
     *
     * @param stackTraceElements
     * @return
     */
    private String stackTraceElementToString(StackTraceElement[] stackTraceElements) {
        StringBuffer stringBuffer = new StringBuffer();
        if (stackTraceElements != null && stackTraceElements.length > 0) {
            for (int i = 0; i < stackTraceElements.length; i++) {
                stringBuffer.append(stackTraceElements[i] + "\n");
            }
        }
        return stringBuffer.toString();
    }


    /**
     * 获取异常简短描述
     *
     * @param throwable
     * @return
     */
    public String getSimpleDescribe(Throwable throwable) {
        if (throwable instanceof RuntimeException) {
            String className = throwable.getClass().getName();
            String message = throwable.getMessage();
            if (StringUtil.isNotEmpty(message) &&
                    message.contains("command denied to user")) {
                //需要刷数据的时候为了避免停服 DBA把帐号权限改成只读的 等刷之后再改正常权限
                return "系统维护中,当前只能进行查看操作,请稍等再试!";
            } else if (StringUtil.isNotEmpty(message) && message.contains("BadSqlGrammarException")) {
                return "sql异常!";
            } else if (StringUtil.isNotEmpty(message) && className.startsWith("com.izk")) {
                //只转发业务异常
                int startIndex = message.indexOf(":", 0);
                int endIndex = message.indexOf('\n', 0);
                if (startIndex != -1 && endIndex != -1 && endIndex > startIndex) {
                    return message.substring(startIndex + 1, endIndex).trim();
                } else {
                    return message;
                }
            }
        }
        return throwable.getMessage();
    }

    /**
     * 格式化显示时间
     *
     * @param localDateTime
     * @return
     */
    public static String formatDateTime(LocalDateTime localDateTime) {
        java.time.Duration duration = java.time.Duration.between(localDateTime, LocalDateTime.now());
        if (duration.toMillis() < 60 * 1000) {
            return duration.getSeconds() + "秒前";
        } else if (duration.toMinutes() < 60) {
            return duration.toMinutes() + "分钟前";
        } else if (duration.toHours() < 24) {
            return duration.toHours() + "小时前";
        } else if (duration.toDays() < 28) {
            return duration.toDays() + "天前";
        } else if (duration.toDays() < 365) {
            return duration.toDays() / 30 + "月前";
        } else {
            return duration.toDays() / 365 + "年前";
        }
    }
}

拦截全局异常，调用error异常的处理类

@ControllerAdvice
public class CallControllerExceptionHandler {

    private static Logger logger = LoggerFactory.getLogger(CallControllerExceptionHandler.class);

    @Resource
    private ErrorToDingtalkService errorToDingtalkService;

    @Resource
    private RequestInfoAdvice requestInfoAdvice;

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Object exceptionHandler(Exception exception) {
        //此处的error级别会自动触发ErrorToDingtalkService中对error日志的处理
        logger.error("system error:{}", requestInfoAdvice.getRequestInfo(), exception);
        if (Strings.isNullOrEmpty(exception.getMessage())
                || !(exception instanceof ClientAbortException
                || exception instanceof MethodArgumentTypeMismatchException
                || exception instanceof HttpMediaTypeNotAcceptableException
                || exception instanceof HttpRequestMethodNotSupportedException)) {
            errorToDingtalkService.handleException(exception);
        }
        return JsonData.error("系统异常,请联系管理员。");
    }
}

在项目中添加错误信息查看的controller，用于查看错误详细

@Slf4j
@RestController
@RequestMapping(value = {"/debug"})
public class DebugController {
    @Resource
    private ICacheOperation cacheOperation;

    @GetMapping(value = "/errorDetail")
    public void changeTime(String errorId, Writer writer) {
        long reslut = cacheOperation.setnx(("/errorDetail").getBytes(), Constants.ACCESS_LIMIT_WAIT_TIME, "1".getBytes());
        if (reslut <= 0) {
            return;
        }
        String errorDetail = cacheOperation.load(errorId);
        StringBuilder sbHtml = new StringBuilder();
        sbHtml.append("<!doctype html><html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">");
        sbHtml.append("<title>异常详情</title></head><body>");
        if (StringUtil.isNotEmpty(errorDetail)) {
            String[] strs = errorDetail.split("\n");
            for (String line : strs) {
                //将业务异常的显示加红
                line = line.replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;");
                if (line.contains("com.**")) {
                    sbHtml.append("<font color ='red'>");
                    sbHtml.append(line);
                    sbHtml.append("</font>");
                } else {
                    sbHtml.append(line);
                }
                sbHtml.append("<br>");
            }
        } else {
            sbHtml.append("<font color ='red'>");
            sbHtml.append("异常信息获取异常,异常编号:" + errorId + ",请查看日志");
            sbHtml.append("</font>");
        }
        sbHtml.append("<br><br><br>");
        sbHtml.append("</body></html>");
        try {
            writer.write(sbHtml.toString());
        } catch (IOException e) {
            log.error(e.getMessage());
        }
    }
}

效果展示

点击上方标红查看详情即展示 

 

总结

      关于钉钉发送消息的工具类封装，之后会在博客中展示。其实这个问题挺好解决的，但是最重要的不去想，相比程序的实现，最难的是能有思路。除了提升变成技能，更重要的要多看，多想，真正的做到解决痛点问题。 

拦截应用 error日志并发送到钉钉群｜Java 开发实战
阿星君
06-19 674
开篇 现在应用都需要对日志进行监控或者报警，现在普遍的做法是采用EKL收集日志，然后再由Grafana进行内容展示和及告警策略等，那如果项目架构比较简单（单体应用），又不想搞那么多中间件依赖怎么办，这里有一种简单的方式可以实现~ 继承UnsynchronizedAppenderBase Springboot默认集成的是logback，所以自定义Appender非常简单，继承一下AppenderBase类即可。 再来看看AppenderBase之上的Appender下都有哪些实现 Unsynch
检查程序运行错误日志并发送钉钉机器人播报
aizhenshi的博客
03-08 2149
检查程序运行错误日志并发送钉钉机器人播报
使用钉钉发送消息（可用于 服务异常通知、定时任务异常通知 等等...）
丶自定义
04-09 4738
一、前言 服务器上有时 定时任务、重要接口等出现异常，导致数据不正常，不能及时通知到服务负责人，及时处理问题。所以引入“钉钉”作为通知工具，当服务出现异常便可立即收到通知，及时处理！ 二、使用方式 1、客户端配置机器人 1、首先需要有阿里巴巴的“钉钉”客户端 2、建立群聊（如果只想通知给自己，不想通知其他人，也可以与他们创建群聊之后再将他们踢出） 3、点击“群设置”里面的“智能群助手” 4、“添加机器人” 5、“添加机器人” 6、选择“自定义” 7、给机...
错误请求拦截---通用版
weixin_47886687的博客
11-10 270
//创建一个axios import axios from 'axios' import { Message } from 'element-ui' const http = axios.create({ baseURL: 'http://157.122.54.189:9095' }) http.interceptors.response.use( res => { console.log('这里拦截到正常响应状态码为200的请求'); //如果状态
Logstash——使用throttle过滤器向钉钉发送预警消息
大风的博客
05-21 2177
之前介绍过logstash的过滤器中有一种throttle过滤器，他可以设置一种规则来进行流量控制，当流量超过预设值时就会为后续的消息添加指定的tag。可以通过使用此过滤器结合阿里钉钉机器人实现发送警报信息到钉钉聊天中。 钉钉机器人的配置 关于钉钉机器人的配置可以查看：钉钉开放平台——机器人开发——自定义机器人开发 logstash配置 数据输入的配置 input { redis { key => "logstash-dingtalk" host => "localhost" pa
兑吧开发规范《源Java手册》
海客森
12-31 3410
1. 规范: 语法规范 1.1. 命名规范 【推荐】业务属性：对象、方法命名，要使用携带业务属性的名词，比如AdvertVO；反例DeleteVO；除非单纯对该对象操作，而对象具备了名词意义，比如AdvertVO中包含方法，getAccountByVO(AdvertVO advertVO) 【强制】代码中的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式 说明: 正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，即使是纯拼音命名方式也要避免采用。 正例: alibaba / taba
8、标准组件
小伙伴的博客
04-08 1345
文章目录 文章目录组织管理组织管理部门管理岗位管理员工管理工作信息账户管理账户管理登录配置安全策略密码策略登录策略角色管理默认角色管理功能权限资源管理页面资源注册权限组件注册权限组件属性权限组件元素属性表格组件表单组件按钮组功能维护功能分配角色权限设置账户权限设置总结示例原界面新界面数据权限无数据权限创建者数据权限使用示例部门数据权限使用示例通用数据权限权限资源定义用户分配资源后台代码使用使用示例...
微信小程序学习指南
weixin_30446197的博客
12-13 3715
作者：初雪链接：https://www.zhihu.com/question/50907897/answer/128494332来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 微信小程序正式公测， 张小龙全面阐述小程序，定档1月9日上线（附90分钟演讲全文） ... 前言：新人第一坑，跳坑指南：修改后，必须保存；ctrl+S； 1：官方工具：http...
java+日志报警_基于log4j2简易实现日志告警
weixin_42350865的博客
02-23 1443
需求系统报ERROR错误时，能实时做到消息通知。思路当前项目比较小，不想过多的依赖额外的第三方组件。项目在ERROR时，都会打印ERROR日志，所以可以在log4j接收到ERROR日志请求时，发送通知消息。实践Filter是log4j2的扩展点，从图中(图片来自如何编写Log4j2脱敏插件)流程可以看到，Filter分别可以在全局、Logger、Appender三个地方做过滤。三个地方对应的log...
监控服务(新增)错误日志脚本并发送DingDing|邮件通知模板
lihuazaizheli的博客
12-21 911
文章目录1.监控模板2.使用脚本3.效果 1.监控模板 vim log_monitor_template.sh #!/bin/bash # sh log_monitor_template.sh $1 $2 $3 $4 $5 $6 $7 #---------------------------------------------------------------------- #FileName: exec.sh #Version: 1.0 #Date: 2016-1
springboot全局异常消息捕获+钉钉自定义消息推送
bigbig_bug的博客
09-10 687
因项目需要，需要配置spring的全局异常消息捕获，并进行钉钉消息推送，使用钉钉的机器人进行消息群推送，以下是钉钉机器人的配置使用 关于钉钉机器人异常消息推送流程备忘录_bigbig_bug的博客-CSDN博客开发的速卖通对接奇门自定义接口，数据安全出塔项目，因为项目需要部署到聚石塔中，但异常信息查看比较麻烦，不利于排查错误信息，所以考虑使用钉钉的机器人进行异常消息推送。首先，你需要一个钉钉账号，其次你需要拉一个群比如我选择创建一个项目群创建完后有一条消息推送，这个是钉钉的机器人，点击它的头像，选择更多机
Spring boot 整合 log4j2日志、程序异常，发送邮件通知
Aesop的博客
08-17 1206
1.Maven修改如下 <!-- 引入 log4j2 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-log4j2</artifactId> </dependency&gt...
使用AOP实现统一日志拦截处理
LeeYuChao的博客
11-15 1112
使用aop实现统一日志处理
SpringBoot - LogAroundAop MVC请求日志拦截
Demon-HY的博客
12-25 1353
代码测试,上线后的调试手段现在很多都喜欢用日志来处理,当我们需要查询某个接口报错的时候,直接看日志,问题描述不清晰, 会发现不知道前端传的什么参数,需要找前端确认,很耗时,所以加了一个请求入参和响应的拦截配置. 需要引入Spring的Aop相关的包: &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/gro...
利用logback封装了输出日志到oracle、mysql等主流关系型数据库的适配器来把日志实时输出到mongodb
kejidaren的博客
06-14 1231
       为了后期的日志统计分析方便，需要把日志保存到数据库，logback封装了输出日志到oracle、mysql等主流关系型数据库的适配器，但由于考虑mongoDB非关系数据库的存取速度和性能比较好以及可以满足日志存储的需求，所以需要自定义实现一个mongoDB的适配器，把日志输出到mongoDB。目前logback配置根据操作日志、性能日志、系统异常日志和sql日志定义四种适配器输出，分...
Spring Boot项目中使用Logback日志与使用AOP拦截请求日志信息
pikcacho_pkq的博客
10-31 2176
日志记录了系统行为的时间、地点等很多细节的具体信息，在发生错误或者接近某种危险状态时能够及时提醒开发人员处理，往往在系统产生问题时承担问题定位与诊断和解决的重要角色。一般很多线上的问题只能通过进行日志分析才可以解决的，所以需要明确日志在日常开发环节中是十分重要的。
springBoot 整合 logback异常告警 发送企业微信
weixin_45423451的博客
03-01 3830
一、项目背景 代码异常的增多(error级别日志增多)也是系统异常的一种，对于这种情况，收到报警消息之后，我们开发同学一般需要登录到线上机器，查看错误日志来排查具体的原因。这种情况下，如果报警消息中能够包括出现异常的上下文以及异常堆栈，不仅能第一时间发现问题，这样的话还能够一定程度上提高问题的排查修复效率。以及我们也要关注线上的异常日志，进而针对异常日志反应的程序问题来相应的优化改造代码。 所以我们就基于企业微信和logback日志系统来实现error级别异常日志发送企业微信群消息报警功能，消息中包括了异常
日志
cloudmagpi的博客
09-08 1081
日志是什么： 日志主要的作用是记录程序运行的过程，通过日志方便观察程序的运行状况和运行过程，便于分析程序的执行过程，JDK自带一个日志，但是效果不太好，速度较慢，要写的代码较多 常见的日志工具 jdk-logging log4j ：其中commons-logging是规范，log4j是commons-logging的实现 要实现log4j首先需要导入两个依赖：log4j和commons-logging <dependency> <groupId>log4j</g
spring boot +logback实现error级别特定日志报警
乔志勇笔记
12-25 1813
maven依赖 &lt;dependency&gt; &lt;groupId&gt;ch.qos.logback&lt;/groupId&gt; &lt;artifactId&gt;logback-core&lt;/artifactId&gt; &lt;version&gt;1.1.8&lt;/version&gt; &lt;/dependency&gt;
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mandy_i

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值