JvmMetrics.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:7k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.metrics.jvm;
  19. import java.lang.management.ManagementFactory;
  20. import java.lang.management.MemoryMXBean;
  21. import java.lang.management.MemoryUsage;
  22. import java.lang.management.ThreadInfo;
  23. import java.lang.management.ThreadMXBean;
  24. import org.apache.hadoop.metrics.MetricsContext;
  25. import org.apache.hadoop.metrics.MetricsRecord;
  26. import org.apache.hadoop.metrics.MetricsUtil;
  27. import org.apache.hadoop.metrics.Updater;
  28. import static java.lang.Thread.State.*;
  29. import java.lang.management.GarbageCollectorMXBean;
  30. import java.util.List;
  31. import org.apache.commons.logging.Log;
  32. import org.apache.commons.logging.LogFactory;
  33. /**
  34.  * Singleton class which reports Java Virtual Machine metrics to the metrics API.  
  35.  * Any application can create an instance of this class in order to emit
  36.  * Java VM metrics.  
  37.  */
  38. public class JvmMetrics implements Updater {
  39.     
  40.     private static final float M = 1024*1024;
  41.     private static JvmMetrics theInstance = null;
  42.     private static Log log = LogFactory.getLog(JvmMetrics.class);
  43.     
  44.     private MetricsRecord metrics;
  45.     
  46.     // garbage collection counters
  47.     private long gcCount = 0;
  48.     private long gcTimeMillis = 0;
  49.     
  50.     // logging event counters
  51.     private long fatalCount = 0;
  52.     private long errorCount = 0;
  53.     private long warnCount  = 0;
  54.     private long infoCount  = 0;
  55.     
  56.     public synchronized static JvmMetrics init(String processName, String sessionId) {
  57.       return init(processName, sessionId, "metrics");
  58.     }
  59.     
  60.     public synchronized static JvmMetrics init(String processName, String sessionId,
  61.       String recordName) {
  62.         if (theInstance != null) {
  63.             log.info("Cannot initialize JVM Metrics with processName=" + 
  64.                      processName + ", sessionId=" + sessionId + 
  65.                      " - already initialized");
  66.         }
  67.         else {
  68.             log.info("Initializing JVM Metrics with processName=" 
  69.                     + processName + ", sessionId=" + sessionId);
  70.             theInstance = new JvmMetrics(processName, sessionId, recordName);
  71.         }
  72.         return theInstance;
  73.     }
  74.     
  75.     /** Creates a new instance of JvmMetrics */
  76.     private JvmMetrics(String processName, String sessionId,
  77.       String recordName) {
  78.         MetricsContext context = MetricsUtil.getContext("jvm");
  79.         metrics = MetricsUtil.createRecord(context, recordName);
  80.         metrics.setTag("processName", processName);
  81.         metrics.setTag("sessionId", sessionId);
  82.         context.registerUpdater(this);
  83.     }
  84.     
  85.     /**
  86.      * This will be called periodically (with the period being configuration
  87.      * dependent).
  88.      */
  89.     public void doUpdates(MetricsContext context) {
  90.         doMemoryUpdates();
  91.         doGarbageCollectionUpdates();
  92.         doThreadUpdates();
  93.         doEventCountUpdates();
  94.         metrics.update();
  95.     }
  96.     
  97.     private void doMemoryUpdates() {
  98.         MemoryMXBean memoryMXBean =
  99.                ManagementFactory.getMemoryMXBean();
  100.         MemoryUsage memNonHeap =
  101.                 memoryMXBean.getNonHeapMemoryUsage();
  102.         MemoryUsage memHeap =
  103.                 memoryMXBean.getHeapMemoryUsage();
  104.         metrics.setMetric("memNonHeapUsedM", memNonHeap.getUsed()/M);
  105.         metrics.setMetric("memNonHeapCommittedM", memNonHeap.getCommitted()/M);
  106.         metrics.setMetric("memHeapUsedM", memHeap.getUsed()/M);
  107.         metrics.setMetric("memHeapCommittedM", memHeap.getCommitted()/M);
  108.     }
  109.     
  110.     private void doGarbageCollectionUpdates() {
  111.         List<GarbageCollectorMXBean> gcBeans =
  112.                 ManagementFactory.getGarbageCollectorMXBeans();
  113.         long count = 0;
  114.         long timeMillis = 0;
  115.         for (GarbageCollectorMXBean gcBean : gcBeans) {
  116.             count += gcBean.getCollectionCount();
  117.             timeMillis += gcBean.getCollectionTime();
  118.         }
  119.         metrics.incrMetric("gcCount", (int)(count - gcCount));
  120.         metrics.incrMetric("gcTimeMillis", (int)(timeMillis - gcTimeMillis));
  121.         
  122.         gcCount = count;
  123.         gcTimeMillis = timeMillis;
  124.     }
  125.     
  126.     private void doThreadUpdates() {
  127.         ThreadMXBean threadMXBean =
  128.                 ManagementFactory.getThreadMXBean();
  129.         long threadIds[] = 
  130.                 threadMXBean.getAllThreadIds();
  131.         ThreadInfo[] threadInfos =
  132.                 threadMXBean.getThreadInfo(threadIds, 0);
  133.         
  134.         int threadsNew = 0;
  135.         int threadsRunnable = 0;
  136.         int threadsBlocked = 0;
  137.         int threadsWaiting = 0;
  138.         int threadsTimedWaiting = 0;
  139.         int threadsTerminated = 0;
  140.         
  141.         for (ThreadInfo threadInfo : threadInfos) {
  142.             // threadInfo is null if the thread is not alive or doesn't exist
  143.             if (threadInfo == null) continue;
  144.             Thread.State state = threadInfo.getThreadState();
  145.             if (state == NEW) {
  146.                 threadsNew++;
  147.             } 
  148.             else if (state == RUNNABLE) {
  149.                 threadsRunnable++;
  150.             }
  151.             else if (state == BLOCKED) {
  152.                 threadsBlocked++;
  153.             }
  154.             else if (state == WAITING) {
  155.                 threadsWaiting++;
  156.             } 
  157.             else if (state == TIMED_WAITING) {
  158.                 threadsTimedWaiting++;
  159.             }
  160.             else if (state == TERMINATED) {
  161.                 threadsTerminated++;
  162.             }
  163.         }
  164.         metrics.setMetric("threadsNew", threadsNew);
  165.         metrics.setMetric("threadsRunnable", threadsRunnable);
  166.         metrics.setMetric("threadsBlocked", threadsBlocked);
  167.         metrics.setMetric("threadsWaiting", threadsWaiting);
  168.         metrics.setMetric("threadsTimedWaiting", threadsTimedWaiting);
  169.         metrics.setMetric("threadsTerminated", threadsTerminated);
  170.     }
  171.     
  172.     private void doEventCountUpdates() {
  173.         long newFatal = EventCounter.getFatal();
  174.         long newError = EventCounter.getError();
  175.         long newWarn  = EventCounter.getWarn();
  176.         long newInfo  = EventCounter.getInfo();
  177.         
  178.         metrics.incrMetric("logFatal", (int)(newFatal - fatalCount));
  179.         metrics.incrMetric("logError", (int)(newError - errorCount));
  180.         metrics.incrMetric("logWarn",  (int)(newWarn - warnCount));
  181.         metrics.incrMetric("logInfo",  (int)(newInfo - infoCount));
  182.         
  183.         fatalCount = newFatal;
  184.         errorCount = newError;
  185.         warnCount  = newWarn;
  186.         infoCount  = newInfo;
  187.     }
  188. }