Finish codes about CPU, memory and some of memory pool.

apm-network/src/main/proto/JVMMetricsService.proto

@@ -24,7 +24,6 @@ message JVMMetric {
 }
 
 message CPU {
-    int64 time = 1;
     double usagePercent = 2;
 }
 
@@ -37,8 +36,8 @@ message Memory {
 }
 
 message MemoryPool {
-    bool isHeap = 1;
-    PoolType type = 2;
+    PoolType type = 1;
+    bool isHeap = 2;
     int64 init = 3;
     int64 max = 4;
     int64 used = 5;

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/JVMService.java

+package org.skywalking.apm.agent.core.jvm;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import org.skywalking.apm.agent.core.boot.BootService;
+import org.skywalking.apm.agent.core.jvm.cpu.CPUProvider;
+import org.skywalking.apm.agent.core.jvm.memory.MemoryProvider;
+import org.skywalking.apm.agent.core.jvm.memorypool.MemoryPoolProvider;
+import org.skywalking.apm.network.proto.JVMMetric;
+
+/**
+ * @author wusheng
+ */
+public class JVMService implements BootService, Runnable {
+    private SimpleDateFormat sdf = new SimpleDateFormat("ss");
+    private volatile ScheduledFuture<?> scheduledFuture;
+
+    @Override
+    public void beforeBoot() throws Throwable {
+
+    }
+
+    @Override
+    public void boot() throws Throwable {
+        ScheduledExecutorService service = Executors
+            .newSingleThreadScheduledExecutor();
+        scheduledFuture = service.scheduleAtFixedRate(this, 0, 1, TimeUnit.SECONDS);
+    }
+
+    @Override
+    public void afterBoot() throws Throwable {
+
+    }
+
+    @Override
+    public void run() {
+        long currentTimeMillis = System.currentTimeMillis();
+        Date day = new Date(currentTimeMillis);
+        String second = sdf.format(day);
+
+        if (Integer.parseInt(second) % 15 == 0) {
+            JVMMetric.Builder JVMBuilder = JVMMetric.newBuilder();
+            JVMBuilder.setTime(currentTimeMillis);
+            JVMBuilder.setCpu(CPUProvider.INSTANCE.getCpuMetric());
+            JVMBuilder.addAllMemory(MemoryProvider.INSTANCE.getMemoryMetricList());
+            JVMBuilder.addAllMemoryPool(MemoryPoolProvider.INSTANCE.getMemoryPoolMetricList());
+        }
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/cpu/CPUMetricAccessor.java

+package org.skywalking.apm.agent.core.jvm.cpu;
+
+import org.skywalking.apm.network.proto.CPU;
+
+/**
+ * @author wusheng
+ */
+public abstract class CPUMetricAccessor {
+    private long lastCPUTimeNs;
+    private long lastSampleTimeNs;
+    private final int cpuCoreNum;
+
+    public CPUMetricAccessor(int cpuCoreNum) {
+        this.cpuCoreNum = cpuCoreNum;
+    }
+
+    protected void init() {
+        lastCPUTimeNs = this.getCpuTime();
+        this.lastSampleTimeNs = System.nanoTime();
+    }
+
+    protected abstract long getCpuTime();
+
+    public CPU getCPUMetric() {
+        long cpuTime = this.getCpuTime();
+        long cpuCost = cpuTime - lastCPUTimeNs;
+        long now = System.nanoTime();
+
+        CPU.Builder cpuBuilder = CPU.newBuilder();
+        return cpuBuilder.setUsagePercent(cpuCost * 1.0d / (now - lastSampleTimeNs) * cpuCoreNum).build();
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/cpu/CPUProvider.java

+package org.skywalking.apm.agent.core.jvm.cpu;
+
+import org.skywalking.apm.agent.core.os.ProcessorUtil;
+import org.skywalking.apm.logging.ILog;
+import org.skywalking.apm.logging.LogManager;
+import org.skywalking.apm.network.proto.CPU;
+
+/**
+ * @author wusheng
+ */
+public enum CPUProvider {
+    INSTANCE;
+    private CPUMetricAccessor cpuMetricAccessor;
+
+    CPUProvider() {
+        int processorNum = ProcessorUtil.getNumberOfProcessors();
+        try {
+            CPUProvider.class.getClassLoader().loadClass("com.sun.management.OperatingSystemMXBean");
+            this.cpuMetricAccessor = new SunCpuAccessor(processorNum);
+        } catch (Exception e) {
+            this.cpuMetricAccessor = new NoSupportedCPUAccessor(processorNum);
+            ILog logger = LogManager.getLogger(CPUProvider.class);
+            logger.error(e, "Only support accessing CPU metric in SUN JVM platform.");
+        }
+    }
+
+    public CPU getCpuMetric() {
+        return cpuMetricAccessor.getCPUMetric();
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/cpu/NoSupportedCPUAccessor.java

+package org.skywalking.apm.agent.core.jvm.cpu;
+
+/**
+ * @author wusheng
+ */
+public class NoSupportedCPUAccessor extends CPUMetricAccessor {
+    public NoSupportedCPUAccessor(int cpuCoreNum) {
+        super(cpuCoreNum);
+    }
+
+    @Override
+    protected long getCpuTime() {
+        return 0;
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/cpu/SunCpuAccessor.java

+package org.skywalking.apm.agent.core.jvm.cpu;
+
+import com.sun.management.OperatingSystemMXBean;
+import java.lang.management.ManagementFactory;
+
+/**
+ * @author wusheng
+ */
+public class SunCpuAccessor extends CPUMetricAccessor {
+    private final OperatingSystemMXBean osMBean;
+
+    public SunCpuAccessor(int cpuCoreNum) {
+        super(cpuCoreNum);
+        this.osMBean = (OperatingSystemMXBean)ManagementFactory.getOperatingSystemMXBean();
+        this.init();
+    }
+
+    @Override
+    protected long getCpuTime() {
+        return osMBean.getProcessCpuTime();
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/memory/MemoryProvider.java

+package org.skywalking.apm.agent.core.jvm.memory;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryMXBean;
+import java.lang.management.MemoryUsage;
+import java.util.LinkedList;
+import java.util.List;
+import org.skywalking.apm.network.proto.Memory;
+
+/**
+ * @author wusheng
+ */
+public enum MemoryProvider {
+    INSTANCE;
+    private final MemoryMXBean memoryMXBean;
+
+    MemoryProvider() {
+        this.memoryMXBean = ManagementFactory.getMemoryMXBean();
+    }
+
+    public List<Memory> getMemoryMetricList() {
+        List<Memory> memoryList = new LinkedList<Memory>();
+
+        MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
+        Memory.Builder heapMemoryBuilder = Memory.newBuilder();
+        heapMemoryBuilder.setIsHeap(true);
+        heapMemoryBuilder.setInit(heapMemoryUsage.getInit());
+        heapMemoryBuilder.setUsed(heapMemoryUsage.getUsed());
+        heapMemoryBuilder.setCommitted(heapMemoryUsage.getCommitted());
+        heapMemoryBuilder.setMax(heapMemoryUsage.getMax());
+        memoryList.add(heapMemoryBuilder.build());
+
+        MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
+        Memory.Builder nonHeapMemoryBuilder = Memory.newBuilder();
+        nonHeapMemoryBuilder.setIsHeap(false);
+        nonHeapMemoryBuilder.setInit(nonHeapMemoryUsage.getInit());
+        nonHeapMemoryBuilder.setUsed(nonHeapMemoryUsage.getUsed());
+        nonHeapMemoryBuilder.setCommitted(nonHeapMemoryUsage.getCommitted());
+        nonHeapMemoryBuilder.setMax(nonHeapMemoryUsage.getMax());
+        memoryList.add(nonHeapMemoryBuilder.build());
+
+        return memoryList;
+    }
+
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/memorypool/CMSCollectorModule.java

+package org.skywalking.apm.agent.core.jvm.memorypool;
+
+import java.lang.management.MemoryPoolMXBean;
+import java.util.List;
+
+/**
+ * @author wusheng
+ */
+public class CMSCollectorModule extends MemoryPoolModule {
+    public CMSCollectorModule(List<MemoryPoolMXBean> beans) {
+        super(beans);
+    }
+
+    @Override protected String getPermName() {
+        return "Perm Gen";
+    }
+
+    @Override protected String getCodeCacheName() {
+        return "Code Cache";
+    }
+
+    @Override protected String getEdenName() {
+        return "Eden Space";
+    }
+
+    @Override protected String getOldName() {
+        return "Tenured Gen";
+    }
+
+    @Override protected String getSurvivorName() {
+        return "Survivor Space";
+    }
+
+    @Override protected String getMetaspaceName() {
+        return "Metaspace";
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/memorypool/MemoryPoolMetricAccessor.java

+package org.skywalking.apm.agent.core.jvm.memorypool;
+
+import java.util.List;
+import org.skywalking.apm.network.proto.MemoryPool;
+
+/**
+ * @author wusheng
+ */
+public interface MemoryPoolMetricAccessor {
+    List<MemoryPool> getMemoryPoolMetricList();
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/memorypool/MemoryPoolModule.java

+package org.skywalking.apm.agent.core.jvm.memorypool;
+
+import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.MemoryUsage;
+import java.util.LinkedList;
+import java.util.List;
+import org.skywalking.apm.network.proto.MemoryPool;
+import org.skywalking.apm.network.proto.PoolType;
+
+/**
+ * @author wusheng
+ */
+public abstract class MemoryPoolModule implements MemoryPoolMetricAccessor {
+    private List<MemoryPoolMXBean> beans;
+
+    public MemoryPoolModule(List<MemoryPoolMXBean> beans) {
+        this.beans = beans;
+    }
+
+    @Override
+    public List<MemoryPool> getMemoryPoolMetricList() {
+        List<MemoryPool> poolList = new LinkedList<MemoryPool>();
+        for (MemoryPoolMXBean bean : beans) {
+            String name = bean.getName();
+            PoolType type = null;
+            if (name.equals(getCodeCacheName())) {
+                type = PoolType.CODE_CACHE_USAGE;
+            } else if (name.equals(getEdenName())) {
+                type = PoolType.NEWGEN_USAGE;
+            } else if (name.equals(getOldName())) {
+                type = PoolType.OLDGEN_USAGE;
+            } else if (name.equals(getSurvivorName())) {
+                type = PoolType.SURVIVOR_USAGE;
+            } else if (name.equals(getMetaspaceName())) {
+                type = PoolType.METASPACE_USAGE;
+            } else if (name.equals(getPermName())) {
+                type = PoolType.PERMGEN_USAGE;
+            }
+
+            if (type != null) {
+                MemoryUsage usage = bean.getUsage();
+                poolList.add(MemoryPool.newBuilder().setType(type)
+                    .setInit(usage.getInit())
+                    .setMax(usage.getMax())
+                    .setCommited(usage.getCommitted())
+                    .setUsed(usage.getUsed())
+                    .build());
+            }
+        }
+        return poolList;
+    }
+
+    protected abstract String getPermName();
+
+    protected abstract String getCodeCacheName();
+
+    protected abstract String getEdenName();
+
+    protected abstract String getOldName();
+
+    protected abstract String getSurvivorName();
+
+    protected abstract String getMetaspaceName();
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/memorypool/MemoryPoolProvider.java

+package org.skywalking.apm.agent.core.jvm.memorypool;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryPoolMXBean;
+import java.util.List;
+import org.skywalking.apm.network.proto.MemoryPool;
+
+/**
+ * @author wusheng
+ */
+public enum MemoryPoolProvider {
+    INSTANCE;
+
+    private MemoryPoolMetricAccessor metricAccessor;
+    private List<MemoryPoolMXBean> beans;
+
+    MemoryPoolProvider() {
+        beans = ManagementFactory.getMemoryPoolMXBeans();
+        for (MemoryPoolMXBean bean : beans) {
+            String name = bean.getName();
+            MemoryPoolMetricAccessor accessor = findByBeanName(name);
+            if (accessor != null) {
+                metricAccessor = accessor;
+                break;
+            }
+        }
+        if (metricAccessor == null) {
+            metricAccessor = new UnknownMemoryPool();
+        }
+    }
+
+    public List<MemoryPool> getMemoryPoolMetricList() {
+        return metricAccessor.getMemoryPoolMetricList();
+    }
+
+    private MemoryPoolMetricAccessor findByBeanName(String name) {
+        if (name.indexOf("PS") > -1) {
+            //Parallel (Old) collector ( -XX:+UseParallelOldGC )
+            return new ParallelCollectorModule(beans);
+        } else if (name.indexOf("CMS") > -1) {
+            // CMS collector ( -XX:+UseConcMarkSweepGC )
+            return new CMSCollectorModule(beans);
+        } else if (name.indexOf("G1") > -1) {
+            // G1 collector ( -XX:+UseG1GC )
+            return null;
+        } else if (name.indexOf("Survivor Space") > -1) {
+            // Serial collector ( -XX:+UseSerialGC )
+            return null;
+        } else {
+            // Unknown
+            return null;
+        }
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/memorypool/ParallelCollectorModule.java

+package org.skywalking.apm.agent.core.jvm.memorypool;
+
+import java.lang.management.MemoryPoolMXBean;
+import java.util.List;
+
+/**
+ * @author wusheng
+ */
+public class ParallelCollectorModule extends MemoryPoolModule{
+
+    public ParallelCollectorModule(List<MemoryPoolMXBean> beans) {
+        super(beans);
+    }
+
+    @Override protected String getPermName() {
+        return "PS Perm Gen";
+    }
+
+    @Override protected String getCodeCacheName() {
+        return "Code Cache";
+    }
+
+    @Override protected String getEdenName() {
+        return "PS Eden Space";
+    }
+
+    @Override protected String getOldName() {
+        return "PS Old Gen";
+    }
+
+    @Override protected String getSurvivorName() {
+        return "PS Survivor Space";
+    }
+
+    @Override protected String getMetaspaceName() {
+        return "Metaspace";
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/jvm/memorypool/UnknownMemoryPool.java

+package org.skywalking.apm.agent.core.jvm.memorypool;
+
+import java.util.LinkedList;
+import java.util.List;
+import org.skywalking.apm.network.proto.MemoryPool;
+import org.skywalking.apm.network.proto.PoolType;
+
+/**
+ * @author wusheng
+ */
+public class UnknownMemoryPool implements MemoryPoolMetricAccessor {
+    @Override
+    public List<MemoryPool> getMemoryPoolMetricList() {
+        List<MemoryPool> poolList = new LinkedList<MemoryPool>();
+        poolList.add(MemoryPool.newBuilder().setType(PoolType.CODE_CACHE_USAGE).build());
+        poolList.add(MemoryPool.newBuilder().setType(PoolType.NEWGEN_USAGE).build());
+        poolList.add(MemoryPool.newBuilder().setType(PoolType.OLDGEN_USAGE).build());
+        poolList.add(MemoryPool.newBuilder().setType(PoolType.SURVIVOR_USAGE).build());
+        poolList.add(MemoryPool.newBuilder().setType(PoolType.PERMGEN_USAGE).build());
+        poolList.add(MemoryPool.newBuilder().setType(PoolType.METASPACE_USAGE).build());
+        return poolList;
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/os/ProcessorUtil.java

+package org.skywalking.apm.agent.core.os;
+
+import java.lang.management.ManagementFactory;
+
+/**
+ * @author wusheng
+ */
+public class ProcessorUtil {
+    public static int getNumberOfProcessors() {
+        return ManagementFactory.getOperatingSystemMXBean().getAvailableProcessors();
+    }
+}

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/remote/GRPCChannelManager.java

@@ -95,7 +95,7 @@ public class GRPCChannelManager implements BootService, Runnable {
 
             resetNextStartTime();
             int waitTime = 5 * 1000;
-            logger.debug("Selected collector grpc service is not available. Wait {} seconds to try", waitTime);
+            logger.debug("Selected collector grpc service is not available. Wait {} millis to try", waitTime);
             try2Sleep(waitTime);
         }
     }

apm-sniffer/apm-agent-core/src/main/resources/META-INF/services/org.skywalking.apm.agent.core.boot.BootService

@@ -3,3 +3,4 @@ org.skywalking.apm.agent.core.context.ContextManager
 org.skywalking.apm.agent.core.remote.CollectorDiscoveryService
 org.skywalking.apm.agent.core.sampling.SamplingService
 org.skywalking.apm.agent.core.remote.GRPCChannelManager
+org.skywalking.apm.agent.core.jvm.JVMService