DolphinScheduler源码分析之任务日志

DolphinScheduler源码分析之任务日志

任务日志打印在调度系统中算是一个比较重要的功能，下面就简要分析一下其打印的逻辑和前端页面查询的流程。

AbstractTask

所有的任务都会继承AbstractTask，这个抽象类有一个比较重要的字段就是logger，其实也就是一个org.slf4j.Logger对象。

也就是说所有的任务都是通过slf4j打印日志的。那这个logger是如何创建的呢？

Logger taskLogger = LoggerFactory.getLogger(LoggerUtils.buildTaskId(LoggerUtils.TASK_LOGGER_INFO_PREFIX,
                    taskInstance.getProcessDefine().getId(),
                    taskInstance.getProcessInstance().getId(),
                    taskInstance.getId()));
public static String buildTaskId(String affix,
                                  int processDefId,
                                  int processInstId,
                                  int taskId){
        // - [taskAppId=TASK_79_4084_15210]
        return String.format(" - [taskAppId=%s-%s-%s-%s]",affix,
                processDefId,
                processInstId,
                taskId);
    }

非常简单，就是通过LoggerFactory.getLogger获取的，名字是由流程定义ID、流程实例ID、任务ID拼接成的。前端查询日志时，taskAppId其实就是logger的名称。通过下图可以很直观的看到，当前任务的流程定义ID是1，流程实例ID是2，任务ID是2 

其实分析到这里，并没有证明最终的进程把日志通过logger写到文件，至少目前没有看到相关的代码。为了更加直观的证明，我们选择Shell类型的任务来分析打印日志的方式。因为它最终创建了一个shell子进程，如果要通过logger字段打印日志，一定会有相关的代码。

ShellCommandExecutor

Shell类型的任务是通过ShellCommandExecutor去执行具体的shell脚本的。

/**
* constructor
* @param logHandler    log handler
* @param taskDir       task dir
* @param taskAppId     task app id
* @param taskInstId    task instance id
* @param tenantCode    tenant code
* @param envFile       env file
* @param startTime     start time
* @param timeout       timeout
* @param logger        logger
*/
public ShellCommandExecutor(Consumer<List<String>> logHandler,
                        String taskDir,
                        String taskAppId,
                        int taskInstId,
                        String tenantCode,
                        String envFile,
                        Date startTime,
                        int timeout,
                        Logger logger)

上面是ShellCommandExecutor的构造函数，通过注释以及参数命名大概可以猜到，logHandler是最终打印日志的地方。下面从其赋值以及如何使用分析日志究竟是不是logger打印的。

this.shellCommandExecutor = new ShellCommandExecutor(this::logHandle, taskProps.getTaskDir(),
            taskProps.getTaskAppId(),
            taskProps.getTaskInstId(),
            taskProps.getTenantCode(),
            taskProps.getEnvFile(),
            taskProps.getTaskStartTime(),
            taskProps.getTaskTimeout(),
            logger);

ShellCommandExecutor创建的时候，logHandler是通过ShellTask的logHandle方法赋值的。

/**
* log handle
* @param logs log list
*/
public void logHandle(List<String> logs) {
// note that the "new line" is added here to facilitate log parsing
logger.info(" -> {}", String.join("\n\t", logs));
}

上面是logHandle的方法定义，很明显就是通过logger打印日志的。

那logHandler是什么时候使用的呢？

AbstractCommandExecutor

ShellCommandExecutor继承了AbstractCommandExecutor，在AbstractCommandExecutor.run中调用了一个非常重要的方法：parseProcessOutput

private void parseProcessOutput(Process process) {
    String threadLoggerInfoName = String.format(LoggerUtils.TASK_LOGGER_THREAD_NAME + "-%s", taskAppId);
    ExecutorService parseProcessOutputExecutorService = ThreadUtils.newDaemonSingleThreadExecutor(threadLoggerInfoName);
    parseProcessOutputExecutorService.submit(new Runnable(){
        @Override
        public void run() {
            BufferedReader inReader = null;

            try {
                inReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                String line;

                long lastFlushTime = System.currentTimeMillis();

                while ((line = inReader.readLine()) != null) {
                    logBuffer.add(line);
                    lastFlushTime = flush(lastFlushTime);
                }
            } catch (Exception e) {
                logger.error(e.getMessage(),e);
            } finally {
                clear();
                close(inReader);
            }
        }
    });
    parseProcessOutputExecutorService.shutdown();
}

parseProcessOutput这个方法就是把Process的标准输入输出打印到了logBuffer中，然后根据条件flush。

private long flush(long lastFlushTime) {
    long now = System.currentTimeMillis();

    /**
     * when log buffer siz or flush time reach condition , then flush
     */
    if (logBuffer.size() >= Constants.defaultLogRowsNum  || now - lastFlushTime > Constants.defaultLogFlushInterval) {
        lastFlushTime = now;
        /** log handle */
        logHandler.accept(logBuffer);

        logBuffer.clear();
    }
    return lastFlushTime;
}

flush就是根据条件（大小、时间）把logBuffer中的内容，通过logHandler打印，其实就是通过logger打印到文件。

分析到这个地方，我们才真正清楚，任务其实就是通过slf4j打印到文件。那么问题又来了，前端是如何查询日志文件的呢？日志文件的路径前端是如何找到的呢？

logback.xml

既然我们知道了是slf4j在打印日志，那么配置文件在哪里呢？

在dolphinscheduler-server模块的resources目录下，有两个logback.xml文件：worker_logback.xml、master_logback.xml。任务打印日志的配置应该是worker_logback.xml，在哪里指定的呢？

dolphinscheduler-daemon.sh文件中有一个关于日志的配置。

-Dlogging.config=classpath:master_logback.xml

上面是worker_logback.xml，可以看到有两个appender，其中TASKLOGFILE是我们关注的对象。它有一个比较关键的filter，根据logback中filter的概念来猜测，这应该就是用来区分workerlogfile这个appender的。也就是说两个appender，会通过filter分别筛选出各自的日志进行打印。

/**
 * Accept or reject based on thread name
 * @param event event
 * @return FilterReply
 */
@Override
public FilterReply decide(ILoggingEvent event) {
    if (event.getThreadName().startsWith(LoggerUtils.TASK_LOGGER_THREAD_NAME) || event.getLevel().isGreaterOrEqual(level)) {
        return FilterReply.ACCEPT;
    }
    return FilterReply.DENY;
}

这个filter根据日志级别和线程名过滤，符合条件的才能打印到当前appender。其实也就是只打印任务线程的日志。

当然了，还配置了Discriminator，它限定了logger的名称符合前面的定义。

/**
 * logger name should be like:
 *     Task Logger name should be like: Task-{processDefinitionId}-{processInstanceId}-{taskInstanceId}
 */
@Override
public String getDiscriminatingValue(ILoggingEvent event) {
    String loggerName = event.getLoggerName()
            .split(Constants.EQUAL_SIGN)[1];
    String prefix = LoggerUtils.TASK_LOGGER_INFO_PREFIX + "-";
    if (loggerName.startsWith(prefix)) {
        return loggerName.substring(prefix.length(),
                loggerName.length() - 1).replace("-","/");
    } else {
        return "unknown_task";
    }
}

LoggerController

前面的分析我们知道，任务的日志其实就是打印到本地日志文件中，那么前端查询的时候估计就是直接读取日志文件然后返回。

但有一个很现实的问题，任务是随机分布在各个worker的，如何读取日志文件呢？

LoggerController.queryLog就是用来查询日志的，它调用了LoggerService.queryLog

public Result queryLog(int taskInstId, int skipLineNum, int limit) {

    TaskInstance taskInstance = processDao.findTaskInstanceById(taskInstId);

    if (taskInstance == null){
      return new Result(Status.TASK_INSTANCE_NOT_FOUND.getCode(), Status.TASK_INSTANCE_NOT_FOUND.getMsg());
    }

    String host = taskInstance.getHost();
    if(StringUtils.isEmpty(host)){
      return new Result(Status.TASK_INSTANCE_NOT_FOUND.getCode(), Status.TASK_INSTANCE_NOT_FOUND.getMsg());
    }

    Result result = new Result(Status.SUCCESS.getCode(), Status.SUCCESS.getMsg());

    logger.info("log host : {} , logPath : {} , logServer port : {}",host,taskInstance.getLogPath(),Constants.RPC_PORT);

    LogClient logClient = new LogClient(host, Constants.RPC_PORT);
    String log = logClient.rollViewLog(taskInstance.getLogPath(),skipLineNum,limit);
    result.setData(log);
    logger.info(log);

    return result;
  }

LoggerService.queryLog的逻辑其实就是通过任务实例ID，查询到了任务所在节点以及日志路径，通过LogClient读取日志。当然了，读取的时候，有限定跳过的行数以及需要读取的行数。

LogClient.rollViewLog其实就是一次rpc调用，它连接到对应host的50051端口，读取日志。

LoggerServer

LoggerServer其实就是一个socket服务，它监听Constants.RPC_PORT（50051）端口的连接，交给LogViewServiceGrpcImpl处理对应的rpc请求。

/**
 * server start
 * @throws IOException io exception
 */
public void start() throws IOException {
    /* The port on which the server should run */
    int port = Constants.RPC_PORT;
    server = ServerBuilder.forPort(port)
            .addService(new LogViewServiceGrpcImpl())
            .build()
            .start();
    logger.info("server started, listening on port : {}" , port);
    Runtime.getRuntime().addShutdownHook(new Thread() {
        @Override
        public void run() {
            // Use stderr here since the logger may have been reset by its JVM shutdown hook.
            logger.info("shutting down gRPC server since JVM is shutting down");
            LoggerServer.this.stop();
            logger.info("server shut down");
        }
    });
}

rollViewLog的实现如下，其实也比较简单，就是调用readFile读取日志文件，然后返回。

public void rollViewLog(LogParameter request, StreamObserver<RetStrInfo> responseObserver) {

    logger.info("log parameter path : {} ,skip line : {}, limit : {}",
            request.getPath(),
            request.getSkipLineNum(),
            request.getLimit());
    List<String> list = readFile(request.getPath(), request.getSkipLineNum(), request.getLimit());
    StringBuilder sb = new StringBuilder();
    boolean errorLineFlag = false;
    for (String line : list){
        sb.append(line + "\r\n");
    }
    RetStrInfo retInfoBuild = RetStrInfo.newBuilder().setMsg(sb.toString()).build();
    responseObserver.onNext(retInfoBuild);
    responseObserver.onCompleted();
}

总结

 

上面是一个简单的流程图，是worker写入日志的流程。

 

这是一个前端读取日志的路程，读取日志的请求按照箭头方向传递，最终由LoggerServer读取本地日志返回给远程的ApiServer，ApiServer返回给前端。