// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you 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 "jvm_metrics.h"

#include <util/jni-util.h>

#include <functional>

#include "common/config.h"

#include "util/defer_op.h"

#include "util/metrics.h"

namespace doris {

#define DEFINE_JVM_SIZE_BYTES_METRIC(name, type)                                     \

    DEFINE_COUNTER_METRIC_PROTOTYPE_5ARG(name##_##type, MetricUnit::BYTES, "", name, \

                                         Labels({{"type", #type}}));

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_heap_size_bytes, max);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_heap_size_bytes, committed);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_heap_size_bytes, used);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_non_heap_size_bytes, used);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_non_heap_size_bytes, committed);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_young_size_bytes, used);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_young_size_bytes, peak_used);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_young_size_bytes, max);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_old_size_bytes, used);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_old_size_bytes, peak_used);

DEFINE_JVM_SIZE_BYTES_METRIC(jvm_old_size_bytes, max);

#define DEFINE_JVM_THREAD_METRIC(type)                                                          \

    DEFINE_COUNTER_METRIC_PROTOTYPE_5ARG(jvm_thread_##type, MetricUnit::NOUNIT, "", jvm_thread, \

                                         Labels({{"type", #type}}));

DEFINE_JVM_THREAD_METRIC(count);

DEFINE_JVM_THREAD_METRIC(peak_count);

DEFINE_JVM_THREAD_METRIC(new_count);

DEFINE_JVM_THREAD_METRIC(runnable_count);

DEFINE_JVM_THREAD_METRIC(blocked_count);

DEFINE_JVM_THREAD_METRIC(waiting_count);

DEFINE_JVM_THREAD_METRIC(timed_waiting_count);

DEFINE_JVM_THREAD_METRIC(terminated_count);

DEFINE_COUNTER_METRIC_PROTOTYPE_5ARG(jvm_gc_g1_young_generation_count, MetricUnit::NOUNIT, "",

                                     jvm_gc,

                                     Labels({{"name", "G1 Young generation Count"},

                                             {"type", "count"}}));

DEFINE_COUNTER_METRIC_PROTOTYPE_5ARG(jvm_gc_g1_young_generation_time_ms, MetricUnit::MILLISECONDS,

                                     "", jvm_gc,

                                     Labels({{"name", "G1 Young generation Time"},

                                             {"type", "time"}}));

DEFINE_COUNTER_METRIC_PROTOTYPE_5ARG(jvm_gc_g1_old_generation_count, MetricUnit::NOUNIT, "", jvm_gc,

                                     Labels({{"name", "G1 Old generation Count"},

                                             {"type", "count"}}));

DEFINE_COUNTER_METRIC_PROTOTYPE_5ARG(jvm_gc_g1_old_generation_time_ms, MetricUnit::MILLISECONDS, "",

                                     jvm_gc,

                                     Labels({{"name", "G1 Old generation Time"},

                                             {"type", "time"}}));

const char* JvmMetrics::_s_hook_name = "jvm_metrics";

JvmMetrics::JvmMetrics(MetricRegistry* registry, JNIEnv* env) {

    DCHECK(registry != nullptr);

    _registry = registry;

    _server_entity = _registry->register_entity("server");

    DCHECK(_server_entity != nullptr);

    do {

        if (!doris::config::enable_jvm_monitor) {

            break;

        }

        try {

            Status st = _jvm_stats.init(env);

            if (!st) {

                LOG(WARNING) << "jvm Stats Init Fail. " << st.to_string();

                break;

            }

        } catch (...) {

            LOG(WARNING) << "jvm Stats Throw Exception Init Fail.";

            break;

        }

        if (!_jvm_stats.init_complete()) {

            break;

        }

        _server_entity->register_hook(_s_hook_name, std::bind(&JvmMetrics::update, this));

    } while (false);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_heap_size_bytes_max);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_heap_size_bytes_committed);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_heap_size_bytes_used);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_non_heap_size_bytes_used);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_non_heap_size_bytes_committed);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_young_size_bytes_used);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_young_size_bytes_peak_used);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_young_size_bytes_max);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_old_size_bytes_used);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_old_size_bytes_peak_used);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_old_size_bytes_max);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_thread_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_thread_peak_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_thread_new_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_thread_runnable_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_thread_blocked_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_thread_waiting_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_thread_timed_waiting_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_thread_terminated_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_gc_g1_young_generation_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_gc_g1_young_generation_time_ms);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_gc_g1_old_generation_count);

    INT_GAUGE_METRIC_REGISTER(_server_entity, jvm_gc_g1_old_generation_time_ms);

}

void JvmMetrics::update() {

    static long fail_count = 0;

    try {

        Status st = _jvm_stats.refresh(this);

        if (!st) {

            fail_count++;

            LOG(WARNING) << "Jvm Stats update Fail! " << st.to_string();

        } else {

            fail_count = 0;

        }

    } catch (...) {

        LOG(WARNING) << "Jvm Stats update throw Exception!";

        fail_count++;

    }

    //When 30 consecutive exceptions occur, turn off jvm information collection.

    if (fail_count >= 30) {

        LOG(WARNING) << "Jvm Stats CLOSE!";

        _jvm_stats.set_complete(false);

        _server_entity->deregister_hook(_s_hook_name);

        jvm_heap_size_bytes_max->set_value(0);

        jvm_heap_size_bytes_committed->set_value(0);

        jvm_heap_size_bytes_used->set_value(0);

        jvm_non_heap_size_bytes_used->set_value(0);

        jvm_non_heap_size_bytes_committed->set_value(0);

        jvm_young_size_bytes_used->set_value(0);

        jvm_young_size_bytes_peak_used->set_value(0);

        jvm_young_size_bytes_max->set_value(0);

        jvm_old_size_bytes_used->set_value(0);

        jvm_old_size_bytes_peak_used->set_value(0);

        jvm_old_size_bytes_max->set_value(0);

        jvm_thread_count->set_value(0);

        jvm_thread_peak_count->set_value(0);

        jvm_thread_new_count->set_value(0);

        jvm_thread_runnable_count->set_value(0);

        jvm_thread_blocked_count->set_value(0);

        jvm_thread_waiting_count->set_value(0);

        jvm_thread_timed_waiting_count->set_value(0);

        jvm_thread_terminated_count->set_value(0);

        jvm_gc_g1_young_generation_count->set_value(0);

        jvm_gc_g1_young_generation_time_ms->set_value(0);

        jvm_gc_g1_old_generation_count->set_value(0);

        jvm_gc_g1_old_generation_time_ms->set_value(0);

    }

}

Status JvmStats::init(JNIEnv* env) {

    RETURN_IF_ERROR(JniUtil::GetGlobalClassRef(env, "java/lang/management/ManagementFactory",

                                               &_managementFactoryClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getMemoryMXBeanMethod, env,

                                    GetStaticMethodID(_managementFactoryClass, "getMemoryMXBean",

                                                      "()Ljava/lang/management/MemoryMXBean;"));

    RETURN_IF_ERROR(JniUtil::GetGlobalClassRef(env, "java/lang/management/MemoryUsage",

                                               &_memoryUsageClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getMemoryUsageUsedMethod, env,

                                    GetMethodID(_memoryUsageClass, "getUsed", "()J"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getMemoryUsageCommittedMethod, env,

                                    GetMethodID(_memoryUsageClass, "getCommitted", "()J"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getMemoryUsageMaxMethod, env,

                                    GetMethodID(_memoryUsageClass, "getMax", "()J"));

    RETURN_IF_ERROR(JniUtil::GetGlobalClassRef(env, "java/lang/management/MemoryMXBean",

                                               &_memoryMXBeanClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getHeapMemoryUsageMethod, env,

                                    GetMethodID(_memoryMXBeanClass, "getHeapMemoryUsage",

                                                "()Ljava/lang/management/MemoryUsage;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getNonHeapMemoryUsageMethod, env,

                                    GetMethodID(_memoryMXBeanClass, "getNonHeapMemoryUsage",

                                                "()Ljava/lang/management/MemoryUsage;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            , _getMemoryPoolMXBeansMethod, env,

            GetStaticMethodID(_managementFactoryClass, "getMemoryPoolMXBeans",

                              "()Ljava/util/List;"));

    RETURN_IF_ERROR(JniUtil::GetGlobalClassRef(env, "java/util/List", &_listClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getListSizeMethod, env,

                                    GetMethodID(_listClass, "size", "()I"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getListUseIndexMethod, env,

                                    GetMethodID(_listClass, "get", "(I)Ljava/lang/Object;"));

    RETURN_IF_ERROR(JniUtil::GetGlobalClassRef(env, "java/lang/management/MemoryPoolMXBean",

                                               &_memoryPoolMXBeanClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getMemoryPoolMXBeanUsageMethod, env,

                                    GetMethodID(_memoryPoolMXBeanClass, "getUsage",

                                                "()Ljava/lang/management/MemoryUsage;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getMemoryPollMXBeanPeakMethod, env,

                                    GetMethodID(_memoryPoolMXBeanClass, "getPeakUsage",

                                                "()Ljava/lang/management/MemoryUsage;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            , _getMemoryPollMXBeanNameMethod, env,

            GetMethodID(_memoryPoolMXBeanClass, "getName", "()Ljava/lang/String;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(, _getThreadMXBeanMethod, env,

                                    GetStaticMethodID(_managementFactoryClass, "getThreadMXBean",

                                                      "()Ljava/lang/management/ThreadMXBean;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            , _getGarbageCollectorMXBeansMethod, env,

            GetStaticMethodID(_managementFactoryClass, "getGarbageCollectorMXBeans",

                              "()Ljava/util/List;"));

    RETURN_IF_ERROR(JniUtil::GetGlobalClassRef(env, "java/lang/management/GarbageCollectorMXBean",

                                               &_garbageCollectorMXBeanClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            , _getGCNameMethod, env,

            GetMethodID(_garbageCollectorMXBeanClass, "getName", "()Ljava/lang/String;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            , _getGCCollectionCountMethod, env,

            GetMethodID(_garbageCollectorMXBeanClass, "getCollectionCount", "()J"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            , _getGCCollectionTimeMethod, env,

            GetMethodID(_garbageCollectorMXBeanClass, "getCollectionTime", "()J"));

    RETURN_IF_ERROR(JniUtil::GetGlobalClassRef(env, "java/lang/management/ThreadMXBean",

                                               &_threadMXBeanClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(,

                                    _getAllThreadIdsMethod, env,

                                    GetMethodID(_threadMXBeanClass, "getAllThreadIds", "()[J"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(,

                                    _getThreadInfoMethod, env,

                                    GetMethodID(_threadMXBeanClass, "getThreadInfo",

                                                "([JI)[Ljava/lang/management/ThreadInfo;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(,

                                    _getPeakThreadCountMethod, env,

                                    GetMethodID(_threadMXBeanClass, "getPeakThreadCount", "()I"));

    RETURN_IF_ERROR(

            JniUtil::GetGlobalClassRef(env, "java/lang/management/ThreadInfo", &_threadInfoClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            ,

            _getThreadStateMethod, env,

            GetMethodID(_threadInfoClass, "getThreadState", "()Ljava/lang/Thread$State;"));

    RETURN_IF_ERROR(JniUtil::GetGlobalClassRef(env, "java/lang/Thread$State", &_threadStateClass));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jfieldID, newThreadFieldID, env,

            GetStaticFieldID(_threadStateClass, "NEW", "Ljava/lang/Thread$State;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jfieldID, runnableThreadFieldID, env,

            GetStaticFieldID(_threadStateClass, "RUNNABLE", "Ljava/lang/Thread$State;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jfieldID, blockedThreadFieldID, env,

            GetStaticFieldID(_threadStateClass, "BLOCKED", "Ljava/lang/Thread$State;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jfieldID, waitingThreadFieldID, env,

            GetStaticFieldID(_threadStateClass, "WAITING", "Ljava/lang/Thread$State;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jfieldID, timedWaitingThreadFieldID, env,

            GetStaticFieldID(_threadStateClass, "TIMED_WAITING", "Ljava/lang/Thread$State;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jfieldID, terminatedThreadFieldID, env,

            GetStaticFieldID(_threadStateClass, "TERMINATED", "Ljava/lang/Thread$State;"));

    JNI_CALL_METHOD_CHECK_EXCEPTION(jobject, newThreadStateObj, env,

                                    GetStaticObjectField(_threadStateClass, newThreadFieldID));

    RETURN_IF_ERROR(JniUtil::LocalToGlobalRef(env, newThreadStateObj, &_newThreadStateObj));

    JNI_CALL_METHOD_CHECK_EXCEPTION(jobject, runnableThreadStateObj, env,

                                    GetStaticObjectField(_threadStateClass, runnableThreadFieldID));

    RETURN_IF_ERROR(

            JniUtil::LocalToGlobalRef(env, runnableThreadStateObj, &_runnableThreadStateObj));

    JNI_CALL_METHOD_CHECK_EXCEPTION(jobject, blockedThreadStateObj, env,

                                    GetStaticObjectField(_threadStateClass, blockedThreadFieldID));

    RETURN_IF_ERROR(JniUtil::LocalToGlobalRef(env, blockedThreadStateObj, &_blockedThreadStateObj));

    JNI_CALL_METHOD_CHECK_EXCEPTION(jobject, waitingThreadStateObj, env,

                                    GetStaticObjectField(_threadStateClass, waitingThreadFieldID));

    RETURN_IF_ERROR(JniUtil::LocalToGlobalRef(env, waitingThreadStateObj, &_waitingThreadStateObj));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jobject, timedWaitingThreadStateObj, env,

            GetStaticObjectField(_threadStateClass, timedWaitingThreadFieldID));

    RETURN_IF_ERROR(JniUtil::LocalToGlobalRef(env, timedWaitingThreadStateObj,

                                              &_timedWaitingThreadStateObj));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jobject, terminatedThreadStateObj, env,

            GetStaticObjectField(_threadStateClass, terminatedThreadFieldID));

    RETURN_IF_ERROR(

            JniUtil::LocalToGlobalRef(env, terminatedThreadStateObj, &_terminatedThreadStateObj));

    _init_complete = true;

    LOG(INFO) << "Start JVM monitoring.";

    return Status::OK();

}

Status JvmStats::refresh(JvmMetrics* jvm_metrics) const {

    if (!_init_complete) {

        return Status::InternalError("Jvm Stats not init complete.");

    }

    JNIEnv* env = nullptr;

    RETURN_IF_ERROR(JniUtil::GetJNIEnv(&env));

    JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

            jobject, memoryMXBeanObj, env,

            CallStaticObjectMethod(_managementFactoryClass, _getMemoryMXBeanMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

            jobject, heapMemoryUsageObj, env,

            CallObjectMethod(memoryMXBeanObj, _getHeapMemoryUsageMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION(jlong, heapMemoryUsed, env,

                                    CallLongMethod(heapMemoryUsageObj, _getMemoryUsageUsedMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jlong, heapMemoryCommitted, env,

            CallLongMethod(heapMemoryUsageObj, _getMemoryUsageCommittedMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION(jlong, heapMemoryMax, env,

                                    CallLongMethod(heapMemoryUsageObj, _getMemoryUsageMaxMethod));

    jvm_metrics->jvm_heap_size_bytes_used->set_value(heapMemoryUsed < 0 ? 0 : heapMemoryUsed);

    jvm_metrics->jvm_heap_size_bytes_committed->set_value(

            heapMemoryCommitted < 0 ? 0 : heapMemoryCommitted);

    jvm_metrics->jvm_heap_size_bytes_max->set_value(heapMemoryMax < 0 ? 0 : heapMemoryMax);

    JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

            jobject, nonHeapMemoryUsageObj, env,

            CallObjectMethod(memoryMXBeanObj, _getNonHeapMemoryUsageMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jlong, nonHeapMemoryCommitted, env,

            CallLongMethod(nonHeapMemoryUsageObj, _getMemoryUsageCommittedMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION(

            jlong, nonHeapMemoryUsed, env,

            CallLongMethod(nonHeapMemoryUsageObj, _getMemoryUsageUsedMethod));

    jvm_metrics->jvm_non_heap_size_bytes_committed->set_value(

            nonHeapMemoryCommitted < 0 ? 0 : nonHeapMemoryCommitted);

    jvm_metrics->jvm_non_heap_size_bytes_used->set_value(nonHeapMemoryUsed < 0 ? 0

                                                                               : nonHeapMemoryUsed);

    JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

            jobject, memoryPoolMXBeansList, env,

            CallStaticObjectMethod(_managementFactoryClass, _getMemoryPoolMXBeansMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION(jint, size, env,

                                    CallIntMethod(memoryPoolMXBeansList, _getListSizeMethod));

    for (int i = 0; i < size; ++i) {

        JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

                jobject, memoryPoolMXBean, env,

                CallObjectMethod(memoryPoolMXBeansList, _getListUseIndexMethod, i));

        JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

                jobject, usageObject, env,

                CallObjectMethod(memoryPoolMXBean, _getMemoryPoolMXBeanUsageMethod));

        JNI_CALL_METHOD_CHECK_EXCEPTION(jlong, used, env,

                                        CallLongMethod(usageObject, _getMemoryUsageUsedMethod));

        JNI_CALL_METHOD_CHECK_EXCEPTION(jlong, max, env,

                                        CallLongMethod(usageObject, _getMemoryUsageMaxMethod));

        JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

                jobject, peakUsageObject, env,

                CallObjectMethod(memoryPoolMXBean, _getMemoryPollMXBeanPeakMethod));

        JNI_CALL_METHOD_CHECK_EXCEPTION(jlong, peakUsed, env,

                                        CallLongMethod(peakUsageObject, _getMemoryUsageUsedMethod));

        JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

                jobject, name, env,

                CallObjectMethod(memoryPoolMXBean, _getMemoryPollMXBeanNameMethod));

        const char* nameStr = env->GetStringUTFChars(

                (jstring)name, nullptr); // GetStringUTFChars not throw exception

        if (nameStr != nullptr) {

            auto it = _memoryPoolName.find(nameStr);

            if (it == _memoryPoolName.end()) {

                continue;

            }

            if (it->second == memoryPoolNameEnum::YOUNG) {

                jvm_metrics->jvm_young_size_bytes_used->set_value(used < 0 ? 0 : used);

                jvm_metrics->jvm_young_size_bytes_peak_used->set_value(peakUsed < 0 ? 0 : peakUsed);

                jvm_metrics->jvm_young_size_bytes_max->set_value(max < 0 ? 0 : max);

            } else if (it->second == memoryPoolNameEnum::OLD) {

                jvm_metrics->jvm_old_size_bytes_used->set_value(used < 0 ? 0 : used);

                jvm_metrics->jvm_old_size_bytes_peak_used->set_value(peakUsed < 0 ? 0 : peakUsed);

                jvm_metrics->jvm_old_size_bytes_max->set_value(max < 0 ? 0 : max);

            }

            env->ReleaseStringUTFChars((jstring)name,

                                       nameStr); // ReleaseStringUTFChars not throw exception

        }

    }

    JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

            jobject, threadMXBean, env,

            CallStaticObjectMethod(_managementFactoryClass, _getThreadMXBeanMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

            jobject, threadIdsObject, env, CallObjectMethod(threadMXBean, _getAllThreadIdsMethod));

    auto threadIds = (jlongArray)threadIdsObject;

    JNI_CALL_METHOD_CHECK_EXCEPTION(jint, threadCount, env, GetArrayLength(threadIds));

    JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

            jobject, threadInfos, env,

            CallObjectMethod(threadMXBean, _getThreadInfoMethod, (jlongArray)threadIds, 0));

    int threadsNew = 0, threadsRunnable = 0, threadsBlocked = 0, threadsWaiting = 0,

        threadsTimedWaiting = 0, threadsTerminated = 0;

    JNI_CALL_METHOD_CHECK_EXCEPTION(jint, peakThreadCount, env,

                                    CallIntMethod(threadMXBean, _getPeakThreadCountMethod));

    jvm_metrics->jvm_thread_peak_count->set_value(peakThreadCount < 0 ? 0 : peakThreadCount);

    jvm_metrics->jvm_thread_count->set_value(threadCount < 0 ? 0 : threadCount);

    for (int i = 0; i < threadCount; i++) {

        JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

                jobject, threadInfo, env, GetObjectArrayElement((jobjectArray)threadInfos, i));

        if (threadInfo == nullptr) {

            continue;

        }

        JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

                jobject, threadState, env, CallObjectMethod(threadInfo, _getThreadStateMethod));

        //IsSameObject not throw exception

        if (env->IsSameObject(threadState, _newThreadStateObj)) {

            threadsNew++;

        } else if (env->IsSameObject(threadState, _runnableThreadStateObj)) {

            threadsRunnable++;

        } else if (env->IsSameObject(threadState, _blockedThreadStateObj)) {

            threadsBlocked++;

        } else if (env->IsSameObject(threadState, _waitingThreadStateObj)) {

            threadsWaiting++;

        } else if (env->IsSameObject(threadState, _timedWaitingThreadStateObj)) {

            threadsTimedWaiting++;

        } else if (env->IsSameObject(threadState, _terminatedThreadStateObj)) {

            threadsTerminated++;

        }

    }

    jvm_metrics->jvm_thread_new_count->set_value(threadsNew < 0 ? 0 : threadsNew);

    jvm_metrics->jvm_thread_runnable_count->set_value(threadsRunnable < 0 ? 0 : threadsRunnable);

    jvm_metrics->jvm_thread_blocked_count->set_value(threadsBlocked < 0 ? 0 : threadsBlocked);

    jvm_metrics->jvm_thread_waiting_count->set_value(threadsWaiting < 0 ? 0 : threadsWaiting);

    jvm_metrics->jvm_thread_timed_waiting_count->set_value(

            threadsTimedWaiting < 0 ? 0 : threadsTimedWaiting);

    jvm_metrics->jvm_thread_terminated_count->set_value(threadsTerminated < 0 ? 0

                                                                              : threadsTerminated);

    JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

            jobject, gcMXBeansList, env,

            CallStaticObjectMethod(_managementFactoryClass, _getGarbageCollectorMXBeansMethod));

    JNI_CALL_METHOD_CHECK_EXCEPTION(jint, numCollectors, env,

                                    CallIntMethod(gcMXBeansList, _getListSizeMethod));

    for (int i = 0; i < numCollectors; i++) {

        JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(

                jobject, gcMXBean, env, CallObjectMethod(gcMXBeansList, _getListUseIndexMethod, i));

        JNI_CALL_METHOD_CHECK_EXCEPTION_DELETE_REF(jobject, gcName, env,

                                                   CallObjectMethod(gcMXBean, _getGCNameMethod));

        JNI_CALL_METHOD_CHECK_EXCEPTION(jlong, gcCollectionCount, env,

                                        CallLongMethod(gcMXBean, _getGCCollectionCountMethod));

        JNI_CALL_METHOD_CHECK_EXCEPTION(jlong, gcCollectionTime, env,

                                        CallLongMethod(gcMXBean, _getGCCollectionTimeMethod));

        const char* gcNameStr = env->GetStringUTFChars((jstring)gcName, NULL);

        if (gcNameStr != nullptr) {

            if (strcmp(gcNameStr, "G1 Young Generation") == 0) {

                jvm_metrics->jvm_gc_g1_young_generation_count->set_value(gcCollectionCount);

                jvm_metrics->jvm_gc_g1_young_generation_time_ms->set_value(gcCollectionTime);

            } else {

                jvm_metrics->jvm_gc_g1_old_generation_count->set_value(gcCollectionCount);

                jvm_metrics->jvm_gc_g1_old_generation_time_ms->set_value(gcCollectionTime);

            }

            env->ReleaseStringUTFChars((jstring)gcName, gcNameStr);

        }

    }

    return Status::OK();

}

JvmStats::~JvmStats() {

    if (!_init_complete) {

        return;

    }

    try {

        JNIEnv* env = nullptr;

        Status st = JniUtil::GetJNIEnv(&env);

        if (!st.ok()) {

            return;

        }

        env->DeleteGlobalRef(_managementFactoryClass);

        env->DeleteGlobalRef(_memoryUsageClass);

        env->DeleteGlobalRef(_memoryMXBeanClass);

        env->DeleteGlobalRef(_listClass);

        env->DeleteGlobalRef(_memoryPoolMXBeanClass);

        env->DeleteGlobalRef(_threadMXBeanClass);

        env->DeleteGlobalRef(_threadInfoClass);

        env->DeleteGlobalRef(_threadStateClass);

        env->DeleteGlobalRef(_garbageCollectorMXBeanClass);

        env->DeleteGlobalRef(_newThreadStateObj);

        env->DeleteGlobalRef(_runnableThreadStateObj);

        env->DeleteGlobalRef(_blockedThreadStateObj);

        env->DeleteGlobalRef(_waitingThreadStateObj);

        env->DeleteGlobalRef(_timedWaitingThreadStateObj);

        env->DeleteGlobalRef(_terminatedThreadStateObj);

    } catch (...) {

        // In order to exit more gracefully, we catch the exception here.

    }

}

} // namespace doris