src/metrics/metrics.cpp

/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "metrics.h"
#include <regex>
#include "string_help.h"

namespace SysTuning {
namespace TraceStreamer {
const uint32_t EXTRA_CHAR = 4;
const uint32_t SEND_FINISH = 1;
Metrics ::Metrics()
{
    metricsFunction_ = {
        {TRACE_MEM, std::bind(&Metrics::InitMemoryStrategy, this, std::placeholders::_1)},
        {TRACE_MEM_TOP_TEN, std::bind(&Metrics::InitMemoryStrategy, this, std::placeholders::_1)},
        {TRACE_MEM_UNAGG, std::bind(&Metrics::InitMemoryUnAggStrategy, this, std::placeholders::_1)},
        {TRACE_TASK_NAMES, std::bind(&Metrics::InitMemoryTaskNameStrategy, this, std::placeholders::_1)},
        {TRACE_STATS, std::bind(&Metrics::InitTraceStatsStrategy, this, std::placeholders::_1)},
        {TRACE_METADATA, std::bind(&Metrics::InitTraceMetaDataStrategy, this, std::placeholders::_1)},
        {SYS_CALLS, std::bind(&Metrics::InitSysCallStrategy, this, std::placeholders::_1)}};
    initMetricsMap_ = {
        {METRICS_TRACE_MEM, TRACE_MEM},
        {METRICS_TRACE_MEM_TOP_TEN, TRACE_MEM_TOP_TEN},
        {METRICS_TRACE_MEM_UNAGG, TRACE_MEM_UNAGG},
        {METRICS_TRACE_TASK_NAMES, TRACE_TASK_NAMES},
        {METRICS_TRACE_STATS, TRACE_STATS},
        {METRICS_TRACE_METADATA, TRACE_METADATA},
        {METRICS_SYS_CALLS, SYS_CALLS},
    };
}

void Metrics::ParserJson(const std::string& metrics, std::string& result)
{
    result = result.substr(EXTRA_CHAR, result.size());
    auto it = metricsFunction_.find(metrics);
    if (it == metricsFunction_.end()) {
        TS_LOGE("Not support metrics!");
        return;
    }
    it->second(result);
}

void Metrics::InitMemoryStrategy(const std::string& result)
{
    json jMessage = json::parse(result);
    const uint32_t TYPE_INFO_ITEM_MAX = 0;
    const uint32_t TYPE_INFO_ITEM_MIN = 1;
    const uint32_t TYPE_INFO_ITEM_AVG = 2;
    const uint32_t PROCESS_METRICES_ITEMS_NAME = 4;
    for (int i = 0; i < jMessage.at("values").size(); i++) {
        TypeInfoItem typeInfoItem;
        typeInfoItem.max = jMessage.at("values")[i].at(TYPE_INFO_ITEM_MAX);
        typeInfoItem.min = jMessage.at("values")[i].at(TYPE_INFO_ITEM_MIN);
        typeInfoItem.avg = jMessage.at("values")[i].at(TYPE_INFO_ITEM_AVG);
        ProcessMetricsItems processMetricsItems;
        processMetricsItems.overallCounters = typeInfoItem;
        processMetricsItems.processName = jMessage.at("values")[i].at(PROCESS_METRICES_ITEMS_NAME);
        memStrategy_.emplace_back(std::move(processMetricsItems));
    }
    return;
}
void Metrics::InitMemoryUnAggStrategy(const std::string& result)
{
    json jMessage = json::parse(result);
    const uint32_t PROCESS_VALUES_ITEM_NAME = 0;
    const uint32_t NAMES = 1;
    const uint32_t VALUES = 2;
    const uint32_t TIMES = 3;
    for (int i = 0; i < jMessage.at("values").size(); i++) {
        ProcessValuesItem processValuesItem;
        if (jMessage.at("values")[i].at(0).is_null()) {
            processValuesItem.processName = "";
        } else {
            processValuesItem.processName = jMessage.at("values")[i].at(PROCESS_VALUES_ITEM_NAME);
        }
        auto names = base::SplitStringToVec(jMessage.at("values")[i].at(NAMES), ",");
        auto values = base::SplitStringToVec(jMessage.at("values")[i].at(VALUES), ",");
        auto times = base::SplitStringToVec(jMessage.at("values")[i].at(TIMES), ",");
        auto oomScoreValue = 0;
        for (auto index = 0; index < names.size(); index++) {
            if (names[index] == "oom_score_adj") {
                oomScoreValue = atoi(values.at(index).c_str());
            }
            TypeItem typeItem;
            typeItem.ts = atoll(times.at(index).c_str());
            typeItem.oomScore = oomScoreValue;
            typeItem.value = atoi(values.at(index).c_str());
            if (names.at(index) == "mem.rss.anon") {
                processValuesItem.anonRss = typeItem;
            } else if (names.at(index) == "mem.swap") {
                processValuesItem.swap = typeItem;
            } else if (names.at(index) == "mem.rss.file") {
                processValuesItem.fileRss = typeItem;
            } else if (names.at(index) == "oom_score_adj") {
                processValuesItem.anonAndSwap = typeItem;
            }
        }
        memAggStrategy_.emplace_back(processValuesItem);
    }
    return;
}
void Metrics::InitMemoryTaskNameStrategy(const std::string& result)
{
    json jMessage = json::parse(result);
    const uint32_t JMESSAGE_VALUE_SIZE_ONE = 1;
    const uint32_t JMESSAGE_VALUE_SIZE_TWO = 2;
    const uint32_t JMESSAGE_VALUE_SIZE_THREE = 3;
    for (int i = 0; i < jMessage.at("values").size(); i++) {
        TaskProcessItem taskProcessItem;
        taskProcessItem.pid = jMessage.at("values")[i].at(JMESSAGE_VALUE_SIZE_ONE);
        if (jMessage.at("values")[i].at(JMESSAGE_VALUE_SIZE_TWO).is_null()) {
            taskProcessItem.processName = "";
        } else {
            taskProcessItem.processName = jMessage.at("values")[i].at(JMESSAGE_VALUE_SIZE_TWO);
        }
        if (!jMessage.at("values")[i].at(JMESSAGE_VALUE_SIZE_THREE).is_null()) {
            taskProcessItem.threadName =
                base::SplitStringToVec(jMessage.at("values")[i].at(JMESSAGE_VALUE_SIZE_THREE), ",");
        }
        taskNameStrategy_.emplace_back(taskProcessItem);
    }
    return;
}
void Metrics::InitTraceStatsStrategy(const std::string& result)
{
    json jMessage = json::parse(result);
    const uint32_t STAT_ITEM_NAME = 0;
    const uint32_t STAT_ITEM_COUNT = 2;
    const uint32_t STAT_ITEM_SOURCE = 3;
    const uint32_t STAT_ITEM_SEVERITY = 4;
    for (int i = 0; i < jMessage.at("values").size(); i++) {
        StatItem statItem;
        statItem.name = jMessage.at("values")[i].at(STAT_ITEM_NAME);
        statItem.count = jMessage.at("values")[i].at(STAT_ITEM_COUNT);
        statItem.source = jMessage.at("values")[i].at(STAT_ITEM_SOURCE);
        statItem.severity = jMessage.at("values")[i].at(STAT_ITEM_SEVERITY);
        statStrategy_.emplace_back(statItem);
    }
    return;
}
void Metrics::InitTraceMetaDataStrategy(const std::string& result)
{
    json jMessage = json::parse(result);
    const uint32_t TRACE_METADATA_ITEM_NAME = 0;
    const uint32_t TRACE_METADATA_ITEM_VALUE = 1;
    for (int i = 0; i < jMessage.at("values").size(); i++) {
        TraceMetadataItem traceMetadataItem;
        traceMetadataItem.name = jMessage.at("values")[i].at(TRACE_METADATA_ITEM_NAME);
        traceMetadataItem.value = jMessage.at("values")[i].at(TRACE_METADATA_ITEM_VALUE);
        metaDataStrategy_.emplace_back(traceMetadataItem);
    }
    return;
}
void Metrics::InitSysCallStrategy(const std::string& result)
{
    json jMessage = json::parse(result);
    const uint32_t FUNCTION_ITEM_DUR_MIN = 1;
    const uint32_t FUNCTION_ITEM_DUR_MAX = 2;
    const uint32_t FUNCTION_ITEM_DUR_AVG = 3;
    const uint32_t FUNCTION_ITEM_FUNCTION_NAME = 4;
    for (int i = 0; i < jMessage.at("values").size(); i++) {
        FunctionItem functionItem;
        functionItem.functionName = jMessage.at("values")[i].at(FUNCTION_ITEM_FUNCTION_NAME);
        functionItem.durMax = jMessage.at("values")[i].at(FUNCTION_ITEM_DUR_MAX);
        functionItem.durMin = jMessage.at("values")[i].at(FUNCTION_ITEM_DUR_MIN);
        functionItem.durAvg = jMessage.at("values")[i].at(FUNCTION_ITEM_DUR_AVG);
        sysCallStrategy_.emplace_back(functionItem);
    }
    return;
}
void Metrics::PrintMetricsResult(uint32_t metricsIndex, ResultCallBack callback)
{
    std::string res = "\r\n";
    std::string metricsName = "";
    std::string repeateValue = "";
    switch (metricsIndex) {
        case METRICS_TRACE_MEM:
            UpdataRepeateValueByTraceMem(repeateValue, metricsName);
            break;
        case METRICS_TRACE_MEM_TOP_TEN:
            UpdataRepeateValueByTopTen(repeateValue, metricsName);
            break;
        case METRICS_TRACE_MEM_UNAGG:
            UpdataRepeateValueByMemUnagg(repeateValue, metricsName);
            break;
        case METRICS_TRACE_TASK_NAMES:
            UpdataRepeateValueByTaskNames(repeateValue, metricsName);
            break;
        case METRICS_TRACE_STATS:
            UpdataRepeateValueByStats(repeateValue, metricsName);
            break;
        case METRICS_TRACE_METADATA:
            UpdataRepeateValueByMetadata(repeateValue, metricsName);
            break;
        case METRICS_SYS_CALLS:
            UpdataRepeateValueBySysCalls(repeateValue, metricsName);
            break;
        default:
            break;
    }
    if (repeateValue != "") {
        repeateValue.pop_back();
    }
    res += metricsName + ": {" + repeateValue + "}";
    res = JsonFormat(res) + "\r\n";
    std::regex strRegex(",");
    auto str = std::regex_replace(res, strRegex, "");
#ifndef IS_WASM
    printf("%s", str.c_str());
#else
    callback(str, SEND_FINISH);
#endif
    return;
}
void Metrics::UpdataRepeateValueByTraceMem(std::string& repeateValue, std::string& metricsName)
{
    metricsName = TRACE_MEM;
    for (auto item : memStrategy_) {
        repeateValue += PROCESS_METRICES + PROCESS_NAME + "\"" + item.processName + "\"," + OVERALL_COUNTERS +
                        ANON_RSS + MIN + std::to_string(item.overallCounters.min) + "," + MAX +
                        std::to_string(item.overallCounters.max) + "," + AVG +
                        std::to_string(item.overallCounters.avg) + "}}},";
    }
}
void Metrics::UpdataRepeateValueByTopTen(std::string& repeateValue, std::string& metricsName)
{
    metricsName = TRACE_MEM_TOP_TEN;
    for (auto item : memStrategy_) {
        repeateValue += PROCESS_METRICES + PROCESS_NAME + "\"" + item.processName + "\"," + OVERALL_COUNTERS +
                        ANON_RSS + MIN + std::to_string(item.overallCounters.min) + "," + MAX +
                        std::to_string(item.overallCounters.max) + "," + AVG +
                        std::to_string(item.overallCounters.avg) + "}}},";
    }
}
void Metrics::UpdataRepeateValueByMemUnagg(std::string& repeateValue, std::string& metricsName)
{
    metricsName = TRACE_MEM_UNAGG;
    for (auto item : memAggStrategy_) {
        repeateValue += PROCESS_VALUES + PROCESS_NAME + "\"" + item.processName + "\"," + ANON_RSS + TS +
                        std::to_string(item.anonRss.ts) + "," + OOM_SCORE + std::to_string(item.anonRss.oomScore) +
                        "," + VALUE + std::to_string(item.anonRss.value) + "}," + FILE_RSS + TS +
                        std::to_string(item.fileRss.ts) + "," + OOM_SCORE + std::to_string(item.fileRss.oomScore) +
                        "," + VALUE + std::to_string(item.fileRss.value) + "}," + SWAP + TS +
                        std::to_string(item.swap.ts) + "," + OOM_SCORE + std::to_string(item.swap.oomScore) + "," +
                        VALUE + std::to_string(item.swap.value) + "}},";
    }
}
void Metrics::UpdataRepeateValueByTaskNames(std::string& repeateValue, std::string& metricsName)
{
    metricsName = TRACE_TASK_NAMES;
    for (auto item : taskNameStrategy_) {
        repeateValue += PROCESS + PID + std::to_string(item.pid) + "," + PROCESS_NAME + "\"" + item.processName + "\",";
        for (auto threadItem : item.threadName) {
            repeateValue += THREAD_NAME + "\"" + threadItem + "\",";
        }
        repeateValue.pop_back();
        repeateValue += "},";
    }
}
void Metrics::UpdataRepeateValueByStats(std::string& repeateValue, std::string& metricsName)
{
    metricsName = TRACE_STATS;
    for (auto item : statStrategy_) {
        repeateValue += STAT + NAME + "\"" + item.name + "\"," + COUNT + std::to_string(item.count) + "," + SOURCE +
                        "\"" + item.source + "\"," + SEVERITY + "\"" + item.severity + "\"" + "},";
    }
}
void Metrics::UpdataRepeateValueByMetadata(std::string& repeateValue, std::string& metricsName)
{
    metricsName = TRACE_METADATA;
    for (auto item : metaDataStrategy_) {
        repeateValue +=
            TRACE_METADATA + ":{" + NAME + "\"" + item.name + "\"," + VALUE + "\"" + item.value + "\"" + "},";
    }
}
void Metrics::UpdataRepeateValueBySysCalls(std::string& repeateValue, std::string& metricsName)
{
    metricsName = SYS_CALLS;
    for (auto item : sysCallStrategy_) {
        repeateValue += FUNCTION + FUNCTION_NAME + "\"" + item.functionName + "\"," + DUR_MAX +
                        std::to_string(item.durMax) + "," + DUR_MIN + std::to_string(item.durMin) + "," + DUR_AVG +
                        std::to_string(item.durAvg) + "},";
    }
}
std::string Metrics::GetLevelSpace(int level)
{
    std::string levelStr = "";
    for (int i = 0; i < level; i++) {
        levelStr += "    ";
    }
    return levelStr;
}
std::string Metrics::JsonFormat(std::string json)
{
    std::string result = "";
    int level = 0;
    for (std::string::size_type index = 0; index < json.size(); index++) {
        char value = json[index];
        if (level > 0 && json[json.size() - 1] == '\n') {
            result += GetLevelSpace(level);
        }
        switch (value) {
            case '{':
            case '[':
                result = result + value + "\n";
                level++;
                result += GetLevelSpace(level);
                break;
            case ',':
                result = result + value + "\n";
                result += GetLevelSpace(level);
                break;
            case '}':
            case ']':
                result += "\n";
                level--;
                result += GetLevelSpace(level);
                result += value;
                break;
            default:
                result += value;
                break;
        }
    }
    return result;
}
} // namespace TraceStreamer
} // namespace SysTuning