// 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 "common/metrics/jvm_metrics.h"

#include <functional>

#include "common/config.h"

#include "common/metrics/metrics.h"

#include "util/defer_op.h"

#include "util/jni-util.h"

#include "util/jvm_launcher.h"

namespace doris {

namespace {

// The env these stats run on, taken from the JVM directly rather than through Jni::Env::Get(),

// and primed as this thread's cached env for as long as the guard lives.

//

// Env::Get() is the gate for code that runs Java of Doris's own, and it refuses whenever the

// plugin SPI could not be resolved. These stats are not that: JvmStats reaches only for

// java.lang.management, which every JVM has and no plugin supplies, and it is published precisely

// so that a BE whose JVM came up through libhdfs alone still reports its Java heap instead of

// having it counted as untracked memory. Routing it through the SPI gate undid that in the one

// deployment it was written for: init() succeeded on the bootstrap thread (env already primed, so

// Env::Get() took its fast path and never asked), while every later refresh() ran on the metrics

// daemon, took the slow path, and got the cached base failure - 30 of those and JvmMetrics::update

// logs "Jvm Stats CLOSE!" and sets every jvm_* gauge to 0. Published once, frozen, then zeroed.

//

// Why a guard around the whole body rather than one call at the top. Two reasons, and neither is

// served by taking the env alone:

//

//  * init() is called from JvmLauncher::_bootstrap(), INSIDE ensure_jvm()'s call_once. Anything

//    on this path that reaches ensure_jvm() - which is what both Jni::Env::Get()'s slow path and

//    JvmLauncher::attach_current_thread() do - re-enters that once flag and hangs the BE on the

//    first JVM it ever creates.

//  * every Jni::Local* this file allocates releases itself through Env::Get() (see

//    RefHelper<Local>::get_env), so an unprimed thread would put each of those destructors back

//    behind the same SPI gate: it logs "Can't destroy Jni Ref" and returns without deleting, once

//    per object, every 15 seconds, on exactly the deployment this indirection exists for.

using ScopedManagementEnv = Jni::JvmLauncher::ScopedVmEnv;

} // namespace

#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) {

    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();

            if (!st) {

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

                break;

            }

        } catch (...) {

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

            break;

        }

    } 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);

    // Last, after every register above. MetricRegistry::trigger_all_hooks runs a hook while it

    // holds both its own lock and MetricEntity::_lock, and this hook re-enters JNI through

    // attach_current_thread() - which, on the metrics daemon thread, blocks on the once flag

    // whichever thread is bringing the JVM up holds. Publishing the hook before these registers means the

    // daemon can be holding the very lock they need while it waits for that flag: an ABBA

    // deadlock that leaves /metrics dead for good. Since the JVM is created on demand, the

    // thread running this constructor is any query thread rather than main().

    if (_jvm_stats.init_complete()) {

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

    }

}

JvmMetrics::~JvmMetrics() {

    if (_jvm_stats.init_complete()) {

        _server_entity->deregister_hook(_s_hook_name);

    }

}

void JvmMetrics::update() {

    // If enable_jvm_monitor is false, the jvm stats object is not initialized. call jvm_stats.refresh() may core.

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

        return;

    }

    static long fail_count = 0;

    if (fail_count >= 30) {

        return;

    }

    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_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() {

    // First declaration in the scope, so it is the last thing destroyed: every JNI wrapper below

    // is released while this is still in force.

    ScopedManagementEnv scoped_env;

    JNIEnv* env = nullptr;

    RETURN_IF_ERROR(scoped_env.attach(&env));

    RETURN_IF_ERROR(Jni::Util::find_class(env, "java/lang/management/ManagementFactory",

                                          &_managementFactoryClass));

    RETURN_IF_ERROR(_managementFactoryClass.get_static_method(

            env, "getMemoryMXBean", "()Ljava/lang/management/MemoryMXBean;",

            &_getMemoryMXBeanMethod));

    RETURN_IF_ERROR(

            Jni::Util::find_class(env, "java/lang/management/MemoryUsage", &_memoryUsageClass));

    RETURN_IF_ERROR(

            _memoryUsageClass.get_method(env, "getUsed", "()J", &_getMemoryUsageUsedMethod));

    RETURN_IF_ERROR(_memoryUsageClass.get_method(env, "getCommitted", "()J",

                                                 &_getMemoryUsageCommittedMethod));

    RETURN_IF_ERROR(_memoryUsageClass.get_method(env, "getMax", "()J", &_getMemoryUsageMaxMethod));

    RETURN_IF_ERROR(

            Jni::Util::find_class(env, "java/lang/management/MemoryMXBean", &_memoryMXBeanClass));

    RETURN_IF_ERROR(_memoryMXBeanClass.get_method(env, "getHeapMemoryUsage",

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

                                                  &_getHeapMemoryUsageMethod));

    RETURN_IF_ERROR(_memoryMXBeanClass.get_method(env, "getNonHeapMemoryUsage",

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

                                                  &_getNonHeapMemoryUsageMethod));

    RETURN_IF_ERROR(_managementFactoryClass.get_static_method(

            env, "getMemoryPoolMXBeans", "()Ljava/util/List;", &_getMemoryPoolMXBeansMethod));

    RETURN_IF_ERROR(Jni::Util::find_class(env, "java/util/List", &_listClass));

    RETURN_IF_ERROR(_listClass.get_method(env, "size", "()I", &_getListSizeMethod));

    RETURN_IF_ERROR(

            _listClass.get_method(env, "get", "(I)Ljava/lang/Object;", &_getListUseIndexMethod));

    RETURN_IF_ERROR(Jni::Util::find_class(env, "java/lang/management/MemoryPoolMXBean",

                                          &_memoryPoolMXBeanClass));

    RETURN_IF_ERROR(_memoryPoolMXBeanClass.get_method(env, "getUsage",

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

                                                      &_getMemoryPoolMXBeanUsageMethod));

    RETURN_IF_ERROR(_memoryPoolMXBeanClass.get_method(env, "getPeakUsage",

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

                                                      &_getMemoryPoolMXBeanPeakMethod));

    RETURN_IF_ERROR(_memoryPoolMXBeanClass.get_method(env, "getName", "()Ljava/lang/String;",

                                                      &_getMemoryPoolMXBeanNameMethod));

    RETURN_IF_ERROR(_managementFactoryClass.get_static_method(

            env, "getThreadMXBean", "()Ljava/lang/management/ThreadMXBean;",

            &_getThreadMXBeanMethod));

    RETURN_IF_ERROR(_managementFactoryClass.get_static_method(env, "getGarbageCollectorMXBeans",

                                                              "()Ljava/util/List;",

                                                              &_getGarbageCollectorMXBeansMethod));

    RETURN_IF_ERROR(Jni::Util::find_class(env, "java/lang/management/GarbageCollectorMXBean",

                                          &_garbageCollectorMXBeanClass));

    RETURN_IF_ERROR(_garbageCollectorMXBeanClass.get_method(env, "getName", "()Ljava/lang/String;",

                                                            &_getGCNameMethod));

    RETURN_IF_ERROR(_garbageCollectorMXBeanClass.get_method(env, "getCollectionCount", "()J",

                                                            &_getGCCollectionCountMethod));

    RETURN_IF_ERROR(_garbageCollectorMXBeanClass.get_method(env, "getCollectionTime", "()J",

                                                            &_getGCCollectionTimeMethod));

    RETURN_IF_ERROR(

            Jni::Util::find_class(env, "java/lang/management/ThreadMXBean", &_threadMXBeanClass));

    RETURN_IF_ERROR(

            _threadMXBeanClass.get_method(env, "getAllThreadIds", "()[J", &_getAllThreadIdsMethod));

    RETURN_IF_ERROR(_threadMXBeanClass.get_method(env, "getThreadInfo",

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

                                                  &_getThreadInfoMethod));

    RETURN_IF_ERROR(_threadMXBeanClass.get_method(env, "getPeakThreadCount", "()I",

                                                  &_getPeakThreadCountMethod));

    RETURN_IF_ERROR(

            Jni::Util::find_class(env, "java/lang/management/ThreadInfo", &_threadInfoClass));

    RETURN_IF_ERROR(_threadInfoClass.get_method(env, "getThreadState", "()Ljava/lang/Thread$State;",

                                                &_getThreadStateMethod));

    RETURN_IF_ERROR(Jni::Util::find_class(env, "java/lang/Thread$State", &_threadStateClass));

    RETURN_IF_ERROR(_threadStateClass.get_static_object_field(

            env, "NEW", "Ljava/lang/Thread$State;", &_newThreadStateObj));

    RETURN_IF_ERROR(_threadStateClass.get_static_object_field(

            env, "RUNNABLE", "Ljava/lang/Thread$State;", &_runnableThreadStateObj));

    RETURN_IF_ERROR(_threadStateClass.get_static_object_field(

            env, "BLOCKED", "Ljava/lang/Thread$State;", &_blockedThreadStateObj));

    RETURN_IF_ERROR(_threadStateClass.get_static_object_field(

            env, "WAITING", "Ljava/lang/Thread$State;", &_waitingThreadStateObj));

    RETURN_IF_ERROR(_threadStateClass.get_static_object_field(

            env, "TIMED_WAITING", "Ljava/lang/Thread$State;", &_timedWaitingThreadStateObj));

    RETURN_IF_ERROR(_threadStateClass.get_static_object_field(

            env, "TERMINATED", "Ljava/lang/Thread$State;", &_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.");

    }

    // First declaration in the scope, so it is the last thing destroyed: every Jni::Local* below

    // is released while this is still in force. See ScopedManagementEnv at the top of this file.

    ScopedManagementEnv scoped_env;

    JNIEnv* env = nullptr;

    RETURN_IF_ERROR(scoped_env.attach(&env));

    Jni::LocalObject memoryMXBeanObj;

    RETURN_IF_ERROR(_managementFactoryClass.call_static_object_method(env, _getMemoryMXBeanMethod)

                            .call(&memoryMXBeanObj));

    Jni::LocalObject heapMemoryUsageObj;

    RETURN_IF_ERROR(memoryMXBeanObj.call_object_method(env, _getHeapMemoryUsageMethod)

                            .call(&heapMemoryUsageObj));

    jlong heapMemoryUsed = 0;

    RETURN_IF_ERROR(heapMemoryUsageObj.call_long_method(env, _getMemoryUsageUsedMethod)

                            .call(&heapMemoryUsed));

    jlong heapMemoryCommitted = 0;

    RETURN_IF_ERROR(heapMemoryUsageObj.call_long_method(env, _getMemoryUsageCommittedMethod)

                            .call(&heapMemoryCommitted));

    jlong heapMemoryMax = 0;

    RETURN_IF_ERROR(heapMemoryUsageObj.call_long_method(env, _getMemoryUsageMaxMethod)

                            .call(&heapMemoryMax));

    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::LocalObject nonHeapMemoryUsageObj;

    RETURN_IF_ERROR(memoryMXBeanObj.call_object_method(env, _getNonHeapMemoryUsageMethod)

                            .call(&nonHeapMemoryUsageObj));

    jlong nonHeapMemoryCommitted = 0;

    RETURN_IF_ERROR(nonHeapMemoryUsageObj.call_long_method(env, _getMemoryUsageCommittedMethod)

                            .call(&nonHeapMemoryCommitted));

    jlong nonHeapMemoryUsed = 0;

    RETURN_IF_ERROR(nonHeapMemoryUsageObj.call_long_method(env, _getMemoryUsageUsedMethod)

                            .call(&nonHeapMemoryUsed));

    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::LocalObject memoryPoolMXBeansList;

    RETURN_IF_ERROR(

            _managementFactoryClass.call_static_object_method(env, _getMemoryPoolMXBeansMethod)

                    .call(&memoryPoolMXBeansList));

    jint beanSize = 0;

    RETURN_IF_ERROR(memoryPoolMXBeansList.call_int_method(env, _getListSizeMethod).call(&beanSize));

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

        Jni::LocalObject memoryPoolMXBean;

        RETURN_IF_ERROR(memoryPoolMXBeansList.call_object_method(env, _getListUseIndexMethod)

                                .with_arg(i)

                                .call(&memoryPoolMXBean));

        Jni::LocalObject usageObject;

        RETURN_IF_ERROR(memoryPoolMXBean.call_object_method(env, _getMemoryPoolMXBeanUsageMethod)

                                .call(&usageObject));

        jlong used = 0;

        RETURN_IF_ERROR(usageObject.call_long_method(env, _getMemoryUsageUsedMethod).call(&used));

        jlong max = 0;

        RETURN_IF_ERROR(usageObject.call_long_method(env, _getMemoryUsageMaxMethod).call(&max));

        Jni::LocalObject peakUsageObject;

        RETURN_IF_ERROR(memoryPoolMXBean.call_object_method(env, _getMemoryPoolMXBeanPeakMethod)

                                .call(&peakUsageObject));

        jlong peakUsed = 0;

        RETURN_IF_ERROR(

                peakUsageObject.call_long_method(env, _getMemoryUsageUsedMethod).call(&peakUsed));

        Jni::LocalString name;

        RETURN_IF_ERROR(memoryPoolMXBean.call_object_method(env, _getMemoryPoolMXBeanNameMethod)

                                .call(&name));

        Jni::LocalStringBufferGuard nameStr;

        RETURN_IF_ERROR(name.get_string_chars(env, &nameStr));

        if (nameStr.get() != nullptr) {

            auto it = _memoryPoolName.find(nameStr.get());

            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);

            }

        }

    }

    Jni::LocalObject threadMXBean;

    RETURN_IF_ERROR(_managementFactoryClass.call_static_object_method(env, _getThreadMXBeanMethod)

                            .call(&threadMXBean));

    Jni::LocalArray threadIds;

    RETURN_IF_ERROR(threadMXBean.call_object_method(env, _getAllThreadIdsMethod).call(&threadIds));

    jsize threadCount = 0;

    RETURN_IF_ERROR(threadIds.get_length(env, &threadCount));

    Jni::LocalArray threadInfos;

    RETURN_IF_ERROR(threadMXBean.call_object_method(env, _getThreadInfoMethod)

                            .with_arg(threadIds)

                            .with_arg(0)

                            .call(&threadInfos));

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

        threadsTimedWaiting = 0, threadsTerminated = 0;

    jint peakThreadCount = 0;

    RETURN_IF_ERROR(

            threadMXBean.call_int_method(env, _getPeakThreadCountMethod).call(&peakThreadCount));

    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::LocalObject threadInfo;

        RETURN_IF_ERROR(threadInfos.get_object_array_element(env, i, &threadInfo));

        if (threadInfo.uninitialized()) {

            continue;

        }

        Jni::LocalObject threadState;

        RETURN_IF_ERROR(

                threadInfo.call_object_method(env, _getThreadStateMethod).call(&threadState));

        if (threadState.equal(env, _newThreadStateObj)) {

            threadsNew++;

        } else if (threadState.equal(env, _runnableThreadStateObj)) {

            threadsRunnable++;

        } else if (threadState.equal(env, _blockedThreadStateObj)) {

            threadsBlocked++;

        } else if (threadState.equal(env, _waitingThreadStateObj)) {

            threadsWaiting++;

        } else if (threadState.equal(env, _timedWaitingThreadStateObj)) {

            threadsTimedWaiting++;

        } else if (threadState.equal(env, _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::LocalObject gcMXBeansList;

    RETURN_IF_ERROR(_managementFactoryClass

                            .call_static_object_method(env, _getGarbageCollectorMXBeansMethod)

                            .call(&gcMXBeansList));

    jint numCollectors = 0;

    RETURN_IF_ERROR(gcMXBeansList.call_int_method(env, _getListSizeMethod).call(&numCollectors));

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

        Jni::LocalObject gcMXBean;

        RETURN_IF_ERROR(gcMXBeansList.call_object_method(env, _getListUseIndexMethod)

                                .with_arg(i)

                                .call(&gcMXBean));

        Jni::LocalString gcName;

        RETURN_IF_ERROR(gcMXBean.call_object_method(env, _getGCNameMethod).call(&gcName));

        jlong gcCollectionCount = 0;

        RETURN_IF_ERROR(gcMXBean.call_long_method(env, _getGCCollectionCountMethod)

                                .call(&gcCollectionCount));

        jlong gcCollectionTime = 0;

        RETURN_IF_ERROR(

                gcMXBean.call_long_method(env, _getGCCollectionTimeMethod).call(&gcCollectionTime));

        Jni::LocalStringBufferGuard gcNameStr;

        RETURN_IF_ERROR(gcName.get_string_chars(env, &gcNameStr));

        if (gcNameStr.get() != nullptr) {

            if (strcmp(gcNameStr.get(), "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);

            }

        }

    }

    return Status::OK();

}

JvmStats::~JvmStats() {}

} // namespace doris