钉钉机器人实现异常预警通知功能

前言

在我们开发过程中，出现bug是非常常见的，不会说产品一旦上线就没有bug，出现bug没关系，关键是需要能够及时发现异常。

当工程基本完成，开始部署到生产环境上，线上的工程一旦出现异常时，开发团队就需要主动感知异常并协调处理，当然人不能一天24小时去盯着线上工程，

所以就需要一种机制来自动化的对异常进行通知，并精确到谁负责的那块代码。这样会极大地方便后续的运维。

本项目的开发愿景是为了给使用者在线上项目的问题排查方面能够带来帮助，简单配置，做到真正的开箱即用，同时异常信息尽量详细，帮助开发者快速定位问题。

目前支持基于钉钉,企业微信和邮箱的异常通知

一、核心代码

这里只展示一些核心代码，具体的完整代码可以看github: spring-boot-exception-notice

1、异常信息数据model

@Data
public class ExceptionInfo {

    /** 工程名 */
    private String project;

    /** 异常的标识码 */
    private String uid;

    /** 请求地址 */
    private String reqAddress;

    /** 方法名 */
    private String methodName;

    /** 方法参数信息 */
    private Object params;

    /** 类路径*/
    private String classPath;

    /** 异常信息 */
    private String exceptionMessage;

    /** 异常追踪信息*/
    private List traceInfo = new ArrayList<>();

    /** 最后一次出现的时间 */
    private LocalDateTime latestShowTime = LocalDateTime.now();
    }

2、异常捕获切面

@Aspect
@RequiredArgsConstructor
public class ExceptionListener {

    private final ExceptionNoticeHandler handler;

    @AfterThrowing(value = "@within(org.springframework.web.bind.annotation.RestController) || @within(org.springframework.stereotype.Controller) || @within(com.jincou.core.aop.ExceptionNotice)", 
    throwing = "e")
    public void doAfterThrow(JoinPoint joinPoint, Exception e) {
        handler.createNotice(e, joinPoint);
    }
}

3、异常信息通知配置类

@Configuration
@ConditionalOnProperty(prefix = ExceptionNoticeProperties.PREFIX, name = "enable", havingValue = "true")
@EnableConfigurationProperties(value = ExceptionNoticeProperties.class)
public class ExceptionNoticeAutoConfiguration {

    private final RestTemplate restTemplate = new RestTemplate();

    @Autowired(required = false)
    private MailSender mailSender;

    /**
     * 注入 异常处理bean
     */
    @Bean(initMethod = "start")
    public ExceptionNoticeHandler nticeHandler(ExceptionNoticeProperties properties) {
        List noticeProcessors = new ArrayList<>(2);
        INoticeProcessor noticeProcessor;
        DingTalkProperties dingTalkProperties = properties.getDingTalk();
        if (null != dingTalkProperties) {
            noticeProcessor = new DingTalkNoticeProcessor(restTemplate, dingTalkProperties);
            noticeProcessors.add(noticeProcessor);
        }
        WeChatProperties weChatProperties = properties.getWeChat();
        if (null != weChatProperties) {
            noticeProcessor = new WeChatNoticeProcessor(restTemplate, weChatProperties);
            noticeProcessors.add(noticeProcessor);
        }

        MailProperties email = properties.getMail();
        if (null != email && null != mailSender) {
            noticeProcessor = new MailNoticeProcessor(mailSender, email);
            noticeProcessors.add(noticeProcessor);
        }

        Assert.isTrue(noticeProcessors.size() != 0, "Exception notification configuration is incorrect");
        return new ExceptionNoticeHandler(properties, noticeProcessors);
    }

    /**
     * 注入异常捕获aop
     */
    @Bean
    @ConditionalOnClass(ExceptionNoticeHandler.class)
    public ExceptionListener exceptionListener(ExceptionNoticeHandler nticeHandler) {
        return new ExceptionListener(nticeHandler);
    }
}

4、异常信息推送处理类

@Slf4j
public class ExceptionNoticeHandler {

    private final String SEPARATOR = System.getProperty("line.separator");

    private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

    private final BlockingQueue exceptionInfoBlockingDeque = new ArrayBlockingQueue<>(1024);

    private final ExceptionNoticeProperties exceptionProperties;

    private final List noticeProcessors;

    public ExceptionNoticeHandler(ExceptionNoticeProperties exceptionProperties,
                                  List noticeProcessors) {
        this.exceptionProperties = exceptionProperties;
        this.noticeProcessors = noticeProcessors;
    }

    /**
     * 将捕获到的异常信息封装好之后发送到阻塞队列
     */
    public Boolean createNotice(Exception ex, JoinPoint joinPoint) {

        //校验当前异常是否是需要 排除的需要统计的异常
        if (containsException(ex)) {
            return null;
        }
        log.error("捕获到异常开始发送消息通知:{}method:{}--->", SEPARATOR, joinPoint.getSignature().getName());
        //获取请求参数
        Object parameter = getParameter(joinPoint);
        //获取当前请求对象
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String address = null;
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            //获取请求地址
            address = request.getRequestURL().toString() + ((request.getQueryString() != null && request.getQueryString().length() > 0) ? "?" + request.getQueryString() : "");
        }

        ExceptionInfo exceptionInfo = new ExceptionInfo(ex, joinPoint.getSignature().getName(), exceptionProperties.getIncludedTracePackage(), parameter, address);
        exceptionInfo.setProject(exceptionProperties.getProjectName());
        return exceptionInfoBlockingDeque.offer(exceptionInfo);
    }

    /**
     * 启动定时任务发送异常通知
     */
    public void start() {
        executor.scheduleAtFixedRate(() -> {
            ExceptionInfo exceptionInfo = exceptionInfoBlockingDeque.poll();
            if (null != exceptionInfo) {
                noticeProcessors.forEach(noticeProcessor -> noticeProcessor.sendNotice(exceptionInfo));
            }
        }, 6, exceptionProperties.getPeriod(), TimeUnit.SECONDS);
    }

    /**
     * 排除的需要统计的异常
     */
    private boolean containsException(Exception exception) {
        Class exceptionClass = exception.getClass();
        List> list = exceptionProperties.getExcludeExceptions();
        for (Class clazz : list) {
            //校验是否存在
            if (clazz.isAssignableFrom(exceptionClass)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 根据方法和传入的参数获取请求参数
     * 注意这里就需要在参数前面加对应的RequestBody 和 RequestParam 注解
     */
    private Object getParameter(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        Parameter[] parameters = method.getParameters();

        Object[] args = joinPoint.getArgs();
        List