/**
 * Binders register one or more metrics to provide information about the state
 * of some aspect of the application or its container.
 * <p>
 * Binders are enabled by default if they source data for an alert
 * that is recommended for a production ready app.
 */
public interface MeterBinder {
    void bindTo(@NonNull MeterRegistry registry);
}

@NonNullApi
@NonNullFields
public class ClassLoaderMetrics implements MeterBinder {
    private final Iterable<Tag> tags;

    public ClassLoaderMetrics() {
        this(emptyList());
    }

    public ClassLoaderMetrics(Iterable<Tag> tags) {
        this.tags = tags;
    }

    @Override
    public void bindTo(MeterRegistry registry) {
        // 通过jmx bean，获取对应的数值
        ClassLoadingMXBean classLoadingBean = ManagementFactory.getClassLoadingMXBean();

        // parameter: (String name, @Nullable T obj, ToDoubleFunction<T> f)
        Gauge.builder("jvm.classes.loaded", classLoadingBean, ClassLoadingMXBean::getLoadedClassCount)
                .tags(tags)
                .description("The number of classes that are currently loaded in the Java virtual machine")
                .baseUnit("classes")
                .register(registry);

        // 单调递增函数计数器
        FunctionCounter.builder("jvm.classes.unloaded", classLoadingBean, ClassLoadingMXBean::getUnloadedClassCount)
                .tags(tags)
                .description("The total number of classes unloaded since the Java virtual machine has started execution")
                .baseUnit("classes")
                .register(registry);
    }
}

public void bindTo(MeterRegistry registry) {
    if (executorService == null) {
        return;
    }

    String className = executorService.getClass().getName();
    if (executorService instanceof ThreadPoolExecutor) {
        monitor(registry, (ThreadPoolExecutor) executorService);
    } else if (className.equals("java.util.concurrent.Executors$DelegatedScheduledExecutorService")) {
        monitor(registry, unwrapThreadPoolExecutor(executorService, executorService.getClass()));
    } else if (className.equals("java.util.concurrent.Executors$FinalizableDelegatedExecutorService")) {
        monitor(registry, unwrapThreadPoolExecutor(executorService, executorService.getClass().getSuperclass()));
    } else if (executorService instanceof ForkJoinPool) {
        monitor(registry, (ForkJoinPool) executorService);
    }
}

/**
 * Every ScheduledThreadPoolExecutor created by {@link Executors} is wrapped. Also,
 * {@link Executors#newSingleThreadExecutor()} wrap a regular {@link ThreadPoolExecutor}.
 */
@Nullable
private ThreadPoolExecutor unwrapThreadPoolExecutor(ExecutorService executor, Class<?> wrapper) {
    try {
        Field e = wrapper.getDeclaredField("e");
        e.setAccessible(true);
        return (ThreadPoolExecutor) e.get(executor);
    } catch (NoSuchFieldException | IllegalAccessException e) {
        // Do nothing. We simply can't get to the underlying ThreadPoolExecutor.
    }
    return null;
}

private void monitor(MeterRegistry registry, @Nullable ThreadPoolExecutor tp) {
    if (tp == null) {
        return;
    }

    FunctionCounter.builder("executor.completed", tp, ThreadPoolExecutor::getCompletedTaskCount)
            .tags(tags)
            .description("The approximate total number of tasks that have completed execution")
            .baseUnit(BaseUnits.TASKS)
            .register(registry);
    // more codes
}