Java获取Prometheus监控数据的方法实现

/**
 * 容器资源监控
 */
@Data
@ApiModel("容器资源监控")
public class DockerResourceMonitorVo {
    /**
     * 实例编码
     */
    @NotNull(message = "容器实例编码不能为空")
    @ApiModelProperty("容器实例编码")
    private String code;

    /**
     * 开始时间
     */
    @ApiModelProperty("开始时间")
    private String startDate;

    /**
     * 结束时间
     */
    @ApiModelProperty("结束时间")
    private String endDate;

    /**
     * 手工输入时间
     */
    @ApiModelProperty("手工输入时间")
    private Integer handWriteTime;

}

public Result<JSONObject> getAllResourceMonitor(DockerResourceMonitorVo body) {
        try {
            //获取开始/结束时间的毫秒数
            String startDate = "";
            String endDate = "";
            //时间为空,则使用默认时间
            if (StringUtils.isEmpty(body.getStartDate()) || StringUtils.isEmpty(body.getEndDate())) {
                //则默认将当前时间往前推15分钟作为开始时间
                Integer timeCycle = 15;
                if (null != body.getHandWriteTime()) { //用户手动输入时间，由前端转成分钟传入
                    timeCycle = body.getHandWriteTime();
                } 
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(new Date());
                calendar.add(Calendar.MINUTE, -timeCycle);
                //设置开始时间毫秒数
                startDate = String.valueOf(calendar.getTimeInMillis());
                //结束时间为空，则使用当前时间
                endDate = String.valueOf(new Date().getTime());
            } else {
                startDate = String.valueOf(DateUtils.yyyyMMddHHmmssWithWhiffletreeToDate(body.getStartDate()).getTime());
                endDate = String.valueOf(DateUtils.yyyyMMddHHmmssWithWhiffletreeToDate(body.getEndDate()).getTime());
            }
            //计算结束时间-开始时间的差值
            long minute = (Long.parseLong(endDate) - Long.parseLong(startDate)) / 1000 / 60;
            //获取步长/采集周期
            String step = getStep(minute);

            //设置请求参数开始时间/结束时间的格式
           // String startTime = StringUtils.substring(startDate, 0, startDate.length() - 3) + ".006";
           // String endTime = StringUtils.substring(endDate, 0, endDate.length() - 3) + ".006";
			String startTime = startDate.substring(0, startDate.length() - 3) + ".006";
			String endTime = endDate.substring(0, endDate.length() - 3) + ".006";
            JSONObject resourceMonitorData = new JSONObject(true);
            //GPU利用率
            JSONObject gpuRate = getGpuRate(body.getCode(), startTime, endTime, step);
            resourceMonitorData.put("gpuRate", gpuRate);
            //GPU显存使用量
            JSONObject gpuMemoryRate = getGpuMemoryRate(body.getCode(), startTime, endTime, step);
            resourceMonitorData.put("gpuMemoryRate", gpuMemoryRate);
            //获取CPU利用率
            JSONObject cpuRate = getCpuRate(body.getCode(), startTime, endTime, step);
            resourceMonitorData.put("cpuRate", cpuRate);
            //内存使用量
            JSONObject memoryRate = getMemoryRate(body.getCode(), startTime, endTime, step);
            resourceMonitorData.put("memoryRate", memoryRate);
            return Result.ok(resourceMonitorData);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ServiceException("获取资源监控失败！");
        }
    }

	 /**
     * 根据时间差获取步长/采集周期
     *
     * @param minute
     * @return
     */
    private String getStep(Long minute) {
        if (minute <= 5) {//5分钟以内
            return "1";
        } else if (minute > 5 && minute <= 60) {//大于5分钟小于1小时
            return "1";
        } else if (minute > 60 && minute <= (60 * 24)) {//1440-->大于1小时小于24小时
            return "30";
        } else if (minute > (60 * 24) && minute <= (60 * 24 * 7)) {//10080-->大于24小时小于一周
            return "300";
        } else if (minute > (60 * 24 * 7) && minute <= (60 * 24 * 7 * 4)) {//40320-->大于1周小于4周
            return "1800";
        } else {//大于4周
            return "43200";
        }
    }

/**
     * 获取cpu利用率 单位：%
     *
     * @param name      容器实例名
     * @param startTime 开始时间字符串
     * @param endTime   结束时间字符串
     * @param step      步长/采集周期
     */
    public JSONObject getCpuRate(String name, String startTime, String endTime, String step) {
        //拼接url   monitorUrl 是我在配置文件中定义的==>http://ip:9090/api/v1/query_range
        String url = monitorUrl + "?query={query}&start={startTime}&end={endTime}&step={step}";

        //设置参数
        Map<String, String> param = new HashMap();
        String query = "sum(rate(container_cpu_user_seconds_total{name='" + name + "'}[5m])) by (name) * 100";
        param.put("query", query);
        param.put("startTime", startTime);
        param.put("endTime", endTime);
        param.put("step", step);

        //发起请求
        JSONObject resultJson = sendResourceMonitor(url, param);
        //解析结果集
        return analyticResult("CPU利用率", resultJson, step, startTime);
    }

    /**
     * 获取内存使用量 单位：GB
     *
     * @param name      容器实例名
     * @param startTime 开始时间字符串
     * @param endTime   结束时间字符串
     * @param step      步长/采集周期
     */
    public JSONObject getMemoryRate(String name, String startTime, String endTime, String step) {
        //拼接url monitorUrl 是我在配置文件中定义的==>http://ip:9090/api/v1/query_range
        String url = monitorUrl + "?query={query}&start={startTime}&end={endTime}&step={step}";

        //设置参数
        Map<String, String> param = new HashMap();
        String query = "sum(container_memory_rss{name='" + name + "'}) by (name) /1024/1024/1024";
        param.put("query", query);
        param.put("startTime", startTime);
        param.put("endTime", endTime);
        param.put("step", step + "");

        //发起请求
        JSONObject resultJson = sendResourceMonitor(url, param);
        //解析结果集
        return analyticResult("内存使用量", resultJson, step, startTime);
    }

    /**
     * 获取GPU利用率 单位：%
     *
     * @param name      容器实例名
     * @param startTime 开始时间字符串
     * @param endTime   结束时间字符串
     * @param step      步长/采集周期
     */
    public JSONObject getGpuRate(String name, String startTime, String endTime, String step) {
        //拼接url monitorUrl 是我在配置文件中定义的==>http://ip:9090/api/v1/query_range
        String url = monitorUrl + "?query={query}&start={startTime}&end={endTime}&step={step}";

        //设置参数
        Map<String, String> param = new HashMap();
        String query = "sum(container_accelerator_duty_cycle{name='" + name + "'}) by(name, acc_id)";
        param.put("query", query);
        param.put("startTime", startTime);
        param.put("endTime", endTime);
        param.put("step", step);

        //发起请求
        JSONObject resultJson = sendResourceMonitor(url, param);
        //解析结果集
        return analyticResult("GPU利用率", resultJson, step, startTime);
    }

    /**
     * 获取GPU显存使用量 单位：GB
     *
     * @param name      容器实例名
     * @param startTime 开始时间字符串
     * @param endTime   结束时间字符串
     * @param step      步长/采集周期
     */
    public JSONObject getGpuMemoryRate(String name, String startTime, String endTime, String step) {
        //拼接url monitorUrl 是我在配置文件中定义的==>http://ip:9090/api/v1/query_range
        String url = monitorUrl + "?query={query}&start={startTime}&end={endTime}&step={step}";

        //设置参数
        Map<String, String> param = new HashMap();
        String query = "sum(container_accelerator_memory_used_bytes{name= '" + name + "'}) by (name, acc_id) /1024/1024/1024";
        param.put("query", query);
        param.put("startTime", startTime);
        param.put("endTime", endTime);
        param.put("step", step);

        //发起请求
        JSONObject resultJson = sendResourceMonitor(url, param);
        //解析结果集
        return analyticResult("GPU显存使用量", resultJson, step, startTime);
    }

    /**
     * 发送HTTP请求Prometheus
     *
     * @param url
     * @param param
     * @return
     */
    public JSONObject sendResourceMonitor(String url, Map<String, String> param) {
        try {
            //发起请求
            Map<String, Object> resultMap = restTemplate.getForObject(url, Map.class, param);
            //将map转为json
            //JSONObject resultJson = JsonUtils.parseObject(JsonUtils.toJSONString(resultMap), JSONObject.class);
            JSONObject resultJson = JSON.parseObject(JSONObject.toJSONString(resultMap), JSONObject.class);
            String status = resultJson.getString("status");
            if (!"success".equals(status)) {
                log.error("资源监控请求失败! url:{}, param:{},", url, param.toString());
                return null;
            }
            return resultJson;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("资源监控请求失败! url:{}, param:{},", url, param.toString());
            return null;
        }

    }

      /**
     * 解析Prometheus返回结果
     *
     * @param title  标题
     * @param result
     * @return
     */
    private JSONObject analyticResult(String title, JSONObject result, String step, String startTime) {
        JSONObject returnJson = new JSONObject();
        JSONArray returnArray = new JSONArray();
        List<String> dateList = new ArrayList<>();//获取时间轴
        if (null == result) {
            return null;
        }
        try {
            //获取result结果集
            JSONArray resultArray = result.getJSONObject("data").getJSONArray("result");
            if (null == resultArray || resultArray.isEmpty()) {
                return null;
            }
            //获取请求的开始时间毫秒数
            long startMillisecond = Long.parseLong(startTime.replace(".", ""));
            for (int i = 0; i < resultArray.size(); i++) {
                JSONObject resultJson = resultArray.getJSONObject(i);
                //获取数据集合
                List<String> valueList = new ArrayList<>();
                JSONObject jsonObject = new JSONObject();
                //获取实例名
                String name = title.contains("GPU") ? "卡" + (i + 1) : title;
                jsonObject.put("name", name);
                //获取values
                JSONArray valuesArray = resultJson.getJSONArray("values");
                long upMillisecond = 0l;
                for (int j = 0; j < valuesArray.size(); j++) {
                    try {
                        JSONArray json = valuesArray.getJSONArray(j);
                        long currentMillisecond = Long.parseLong(json.getString(0).replace(".", ""));
                        if (j == 0) {//flag：true-->如果查询范围为5天，而容器却在昨天购买，前3天的日期轴没有，通过对比查询时间与数据返回时间，补齐时间轴
                            verifyCompleteTimeline(startMillisecond, currentMillisecond, step, (i == 0), true, dateList, valueList);
                        }
                        //flag：false-->如果查询范围为3天，机器第1,3天开启，在第2天关机，则Prometheus不会返回第二天的数据，时间轴只有第一天和第三天的数据，直接跳过第二天
                        if (verifyCompleteTimeline(upMillisecond, currentMillisecond, step, (i == 0), false, dateList, valueList)) {
                            upMillisecond = DateUtils.yyyyMMddHHmmssWithWhiffletreeToDate(dateList.get(dateList.size() - 1)).getTime();
                            continue;
                        }
                        if (i == 0) {
                            dateList.add(DateUtils.yyyyMMddHHmmssWithWhiffletree(new Date(currentMillisecond)));
                        }
                        upMillisecond = currentMillisecond;
                        double value = Double.valueOf(json.getString(1));
                        // 如果是CPU或GPU利用率 则保留两位小数
                        if (title.contains("CPU利用率") || title.contains("GPU利用率")) {
                            valueList.add(String.format("%.2f", value));
                        } else {//保留一位小数
                            valueList.add(String.format("%.1f", value));
                        }
                    } catch (Exception e) {
                        //转换失败,将上一次的结果赋值本次或跳过
                        e.printStackTrace();
                        if (dateList.size() == 0) {
                            continue;
                        }
                        if (i == 0 && dateList.size() == valueList.size()) {
                            //根据上一个日期毫秒，和步长，设置当前时间轴，确保时间轴的连续性
                            dateList.add(DateUtils.yyyyMMddHHmmssWithWhiffletree(new Date(upMillisecond + (Long.parseLong(step) * 1000))));
                        }
                        valueList.add("0");//转换失败，值设置为0。
                        continue;
                    }
                }
                jsonObject.put("value", valueList);
                returnArray.add(jsonObject);
            }
            returnJson.put("title", title);
            returnJson.put("date", dateList);
            returnJson.put("values", returnArray);
        } catch (Exception e) {
            e.printStackTrace();
            log.error(title + ": 解析结果集错误：{}", e.getMessage());
            return null;
        }
        return returnJson;
    }


    /**
     * 校验时间轴及数据
     * 问题1：如果查询范围为3天，机器第1,3天开启，在第2天关机，则Prometheus不会返回第二天的数据，时间轴只有第一天和第三天的数据，直接跳过第二天
     * 解决1：根据上一次时间加步长赋值时间轴，确保时间轴连续性，值为""；
     * 问题2: 如果查询近七天的数据，容器是在昨天购买，时间轴只有昨天到现在的，前五天的没有
     * 解决2： 根据查询开始时间和数据返回的第一条作对比，补齐时间轴
     * @param upMillisecond      上一次时间毫秒值
     * @param currentMillisecond 本次时间毫秒值
     * @param step               步长/采集周期
     * @param isDate             是否对日期轴进行添加  true：是  false：否
     * @param flag               true：补齐购买容器之前的日期  false：补齐关机期间的日期
     * @param dateList           日期集合
     * @param valueList          数据集合
     * @return true: 有时间差距，需补充时间轴   false：无时间差距
     */
    private boolean verifyCompleteTimeline(Long upMillisecond, Long currentMillisecond, String step, boolean isDate, boolean flag, List<String> dateList, List<String> valueList) {
        if (upMillisecond == 0 && !flag) {
            return false;
        }
        long count = (currentMillisecond - upMillisecond) / (Long.parseLong(step) * 1000);
        if (count == 1) {
            return false;
        }
//        log.error("资源监控-->日期时间缺失，开始补充:{}", dateList.get((dateList.size() - 1)));
        for (int i = 0; i < count; i++) {
            if (isDate) {
                //补充时间差距，确保日期轴的完整性
                long dateMillisecond = upMillisecond + Long.parseLong(step) * 1000 * (i + 1);
                dateList.add(DateUtils.yyyyMMddHHmmssWithWhiffletree(new Date(dateMillisecond)));
            }
            valueList.add("");
        }
//        log.error("资源监控-->日期时间缺失，结束补充:{}", dateList.get((dateList.size() - 1)));
        return true;
    }

import org.springframework.util.StringUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtils {

    public static String yyyyMMddHHmmssWithWhiffletree(Date date) {
        if(date == null) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(date);
    }

    public static Date yyyyMMddHHmmssWithWhiffletreeToDate(String dateStr) throws ParseException {
        if(!StringUtils.hasText(dateStr)) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.parse(dateStr);
    }

}