View Javadoc

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  
19  package org.apache.hadoop.hbase.regionserver;
20  
21  import org.apache.hadoop.hbase.classification.InterfaceAudience;
22  import org.apache.hadoop.hbase.metrics.BaseSourceImpl;
23  import org.apache.hadoop.hbase.metrics.Interns;
24  import org.apache.hadoop.metrics2.MetricHistogram;
25  import org.apache.hadoop.metrics2.MetricsCollector;
26  import org.apache.hadoop.metrics2.MetricsRecordBuilder;
27  import org.apache.hadoop.metrics2.lib.MutableFastCounter;
28  
29  /**
30   * Hadoop2 implementation of MetricsRegionServerSource.
31   *
32   * Implements BaseSource through BaseSourceImpl, following the pattern
33   */
34  @InterfaceAudience.Private
35  public class MetricsRegionServerSourceImpl
36      extends BaseSourceImpl implements MetricsRegionServerSource {
37  
38    final MetricsRegionServerWrapper rsWrap;
39    private final MetricHistogram putHisto;
40    private final MetricHistogram putBatchHisto;
41    private final MetricHistogram deleteHisto;
42    private final MetricHistogram deleteBatchHisto;
43    private final MetricHistogram checkAndDeleteHisto;
44    private final MetricHistogram checkAndPutHisto;
45    private final MetricHistogram getHisto;
46    private final MetricHistogram incrementHisto;
47    private final MetricHistogram appendHisto;
48    private final MetricHistogram replayHisto;
49    private final MetricHistogram scanSizeHisto;
50    private final MetricHistogram scanTimeHisto;
51  
52    private final MutableFastCounter slowPut;
53    private final MutableFastCounter slowDelete;
54    private final MutableFastCounter slowGet;
55    private final MutableFastCounter slowIncrement;
56    private final MutableFastCounter slowAppend;
57    private final MutableFastCounter splitRequest;
58    private final MutableFastCounter splitSuccess;
59  
60    private final MetricHistogram splitTimeHisto;
61  
62    // flush related metrics
63    private final MetricHistogram flushTimeHisto;
64    private final MetricHistogram flushMemstoreSizeHisto;
65    private final MetricHistogram flushOutputSizeHisto;
66    private final MutableFastCounter flushedMemstoreBytes;
67    private final MutableFastCounter flushedOutputBytes;
68  
69    // compaction related metrics
70    private final MetricHistogram compactionTimeHisto;
71    private final MetricHistogram compactionInputFileCountHisto;
72    private final MetricHistogram compactionInputSizeHisto;
73    private final MetricHistogram compactionOutputFileCountHisto;
74    private final MetricHistogram compactionOutputSizeHisto;
75    private final MutableFastCounter compactedInputBytes;
76    private final MutableFastCounter compactedOutputBytes;
77  
78    private final MetricHistogram majorCompactionTimeHisto;
79    private final MetricHistogram majorCompactionInputFileCountHisto;
80    private final MetricHistogram majorCompactionInputSizeHisto;
81    private final MetricHistogram majorCompactionOutputFileCountHisto;
82    private final MetricHistogram majorCompactionOutputSizeHisto;
83    private final MutableFastCounter majorCompactedInputBytes;
84    private final MutableFastCounter majorCompactedOutputBytes;
85  
86    // pause monitor metrics
87    private final MutableFastCounter infoPauseThresholdExceeded;
88    private final MutableFastCounter warnPauseThresholdExceeded;
89    private final MetricHistogram pausesWithGc;
90    private final MetricHistogram pausesWithoutGc;
91  
92    public MetricsRegionServerSourceImpl(MetricsRegionServerWrapper rsWrap) {
93      this(METRICS_NAME, METRICS_DESCRIPTION, METRICS_CONTEXT, METRICS_JMX_CONTEXT, rsWrap);
94    }
95  
96    public MetricsRegionServerSourceImpl(String metricsName,
97                                         String metricsDescription,
98                                         String metricsContext,
99                                         String metricsJmxContext,
100                                        MetricsRegionServerWrapper rsWrap) {
101     super(metricsName, metricsDescription, metricsContext, metricsJmxContext);
102     this.rsWrap = rsWrap;
103 
104     putHisto = getMetricsRegistry().newTimeHistogram(PUT_KEY);
105     putBatchHisto = getMetricsRegistry().newTimeHistogram(PUT_BATCH_KEY);
106     slowPut = getMetricsRegistry().newCounter(SLOW_PUT_KEY, SLOW_PUT_DESC, 0L);
107 
108     deleteHisto = getMetricsRegistry().newTimeHistogram(DELETE_KEY);
109     slowDelete = getMetricsRegistry().newCounter(SLOW_DELETE_KEY, SLOW_DELETE_DESC, 0L);
110 
111     deleteBatchHisto = getMetricsRegistry().newTimeHistogram(DELETE_BATCH_KEY);
112     checkAndDeleteHisto = getMetricsRegistry().newTimeHistogram(CHECK_AND_DELETE_KEY);
113     checkAndPutHisto = getMetricsRegistry().newTimeHistogram(CHECK_AND_PUT_KEY);
114 
115     getHisto = getMetricsRegistry().newTimeHistogram(GET_KEY);
116     slowGet = getMetricsRegistry().newCounter(SLOW_GET_KEY, SLOW_GET_DESC, 0L);
117 
118     incrementHisto = getMetricsRegistry().newTimeHistogram(INCREMENT_KEY);
119     slowIncrement = getMetricsRegistry().newCounter(SLOW_INCREMENT_KEY, SLOW_INCREMENT_DESC, 0L);
120 
121     appendHisto = getMetricsRegistry().newTimeHistogram(APPEND_KEY);
122     slowAppend = getMetricsRegistry().newCounter(SLOW_APPEND_KEY, SLOW_APPEND_DESC, 0L);
123 
124     replayHisto = getMetricsRegistry().newTimeHistogram(REPLAY_KEY);
125     scanSizeHisto = getMetricsRegistry().newSizeHistogram(SCAN_SIZE_KEY);
126     scanTimeHisto = getMetricsRegistry().newTimeHistogram(SCAN_TIME_KEY);
127 
128     flushTimeHisto = getMetricsRegistry().newTimeHistogram(FLUSH_TIME, FLUSH_TIME_DESC);
129     flushMemstoreSizeHisto = getMetricsRegistry()
130         .newSizeHistogram(FLUSH_MEMSTORE_SIZE, FLUSH_MEMSTORE_SIZE_DESC);
131     flushOutputSizeHisto = getMetricsRegistry().newSizeHistogram(FLUSH_OUTPUT_SIZE,
132       FLUSH_OUTPUT_SIZE_DESC);
133     flushedOutputBytes = getMetricsRegistry().newCounter(FLUSHED_OUTPUT_BYTES,
134       FLUSHED_OUTPUT_BYTES_DESC, 0L);
135     flushedMemstoreBytes = getMetricsRegistry().newCounter(FLUSHED_MEMSTORE_BYTES,
136       FLUSHED_MEMSTORE_BYTES_DESC, 0L);
137 
138     compactionTimeHisto = getMetricsRegistry()
139         .newTimeHistogram(COMPACTION_TIME, COMPACTION_TIME_DESC);
140     compactionInputFileCountHisto = getMetricsRegistry()
141       .newHistogram(COMPACTION_INPUT_FILE_COUNT, COMPACTION_INPUT_FILE_COUNT_DESC);
142     compactionInputSizeHisto = getMetricsRegistry()
143         .newSizeHistogram(COMPACTION_INPUT_SIZE, COMPACTION_INPUT_SIZE_DESC);
144     compactionOutputFileCountHisto = getMetricsRegistry()
145         .newHistogram(COMPACTION_OUTPUT_FILE_COUNT, COMPACTION_OUTPUT_FILE_COUNT_DESC);
146     compactionOutputSizeHisto = getMetricsRegistry()
147       .newSizeHistogram(COMPACTION_OUTPUT_SIZE, COMPACTION_OUTPUT_SIZE_DESC);
148     compactedInputBytes = getMetricsRegistry()
149         .newCounter(COMPACTED_INPUT_BYTES, COMPACTED_INPUT_BYTES_DESC, 0L);
150     compactedOutputBytes = getMetricsRegistry()
151         .newCounter(COMPACTED_OUTPUT_BYTES, COMPACTED_OUTPUT_BYTES_DESC, 0L);
152 
153     majorCompactionTimeHisto = getMetricsRegistry()
154         .newTimeHistogram(MAJOR_COMPACTION_TIME, MAJOR_COMPACTION_TIME_DESC);
155     majorCompactionInputFileCountHisto = getMetricsRegistry()
156       .newHistogram(MAJOR_COMPACTION_INPUT_FILE_COUNT, MAJOR_COMPACTION_INPUT_FILE_COUNT_DESC);
157     majorCompactionInputSizeHisto = getMetricsRegistry()
158         .newSizeHistogram(MAJOR_COMPACTION_INPUT_SIZE, MAJOR_COMPACTION_INPUT_SIZE_DESC);
159     majorCompactionOutputFileCountHisto = getMetricsRegistry()
160         .newHistogram(MAJOR_COMPACTION_OUTPUT_FILE_COUNT, MAJOR_COMPACTION_OUTPUT_FILE_COUNT_DESC);
161     majorCompactionOutputSizeHisto = getMetricsRegistry()
162       .newSizeHistogram(MAJOR_COMPACTION_OUTPUT_SIZE, MAJOR_COMPACTION_OUTPUT_SIZE_DESC);
163     majorCompactedInputBytes = getMetricsRegistry()
164         .newCounter(MAJOR_COMPACTED_INPUT_BYTES, MAJOR_COMPACTED_INPUT_BYTES_DESC, 0L);
165     majorCompactedOutputBytes = getMetricsRegistry()
166         .newCounter(MAJOR_COMPACTED_OUTPUT_BYTES, MAJOR_COMPACTED_OUTPUT_BYTES_DESC, 0L);
167 
168     splitTimeHisto = getMetricsRegistry().newTimeHistogram(SPLIT_KEY);
169     splitRequest = getMetricsRegistry().newCounter(SPLIT_REQUEST_KEY, SPLIT_REQUEST_DESC, 0L);
170     splitSuccess = getMetricsRegistry().newCounter(SPLIT_SUCCESS_KEY, SPLIT_SUCCESS_DESC, 0L);
171 
172     // pause monitor metrics
173     infoPauseThresholdExceeded = getMetricsRegistry().newCounter(INFO_THRESHOLD_COUNT_KEY,
174       INFO_THRESHOLD_COUNT_DESC, 0L);
175     warnPauseThresholdExceeded = getMetricsRegistry().newCounter(WARN_THRESHOLD_COUNT_KEY,
176       WARN_THRESHOLD_COUNT_DESC, 0L);
177     pausesWithGc = getMetricsRegistry().newTimeHistogram(PAUSE_TIME_WITH_GC_KEY);
178     pausesWithoutGc = getMetricsRegistry().newTimeHistogram(PAUSE_TIME_WITHOUT_GC_KEY);
179   }
180 
181   @Override
182   public void updatePut(long t) {
183     putHisto.add(t);
184   }
185 
186   @Override
187   public void updateDelete(long t) {
188     deleteHisto.add(t);
189   }
190 
191   @Override
192   public void updateGet(long t) {
193     getHisto.add(t);
194   }
195 
196   @Override
197   public void updateIncrement(long t) {
198     incrementHisto.add(t);
199   }
200 
201   @Override
202   public void updateAppend(long t) {
203     appendHisto.add(t);
204   }
205 
206   @Override
207   public void updateReplay(long t) {
208     replayHisto.add(t);
209   }
210 
211   @Override
212   public void updateScanSize(long scanSize) {
213     scanSizeHisto.add(scanSize);
214   }
215 
216   @Override
217   public void updateScanTime(long t) {
218     scanTimeHisto.add(t);
219   }
220 
221   @Override
222   public void incrSlowPut() {
223    slowPut.incr();
224   }
225 
226   @Override
227   public void incrSlowDelete() {
228     slowDelete.incr();
229   }
230 
231   @Override
232   public void incrSlowGet() {
233     slowGet.incr();
234   }
235 
236   @Override
237   public void incrSlowIncrement() {
238     slowIncrement.incr();
239   }
240 
241   @Override
242   public void incrSlowAppend() {
243     slowAppend.incr();
244   }
245 
246   @Override
247   public void incrSplitRequest() {
248     splitRequest.incr();
249   }
250 
251   @Override
252   public void incrSplitSuccess() {
253     splitSuccess.incr();
254   }
255 
256   @Override
257   public void updateSplitTime(long t) {
258     splitTimeHisto.add(t);
259   }
260 
261   @Override
262   public void updateFlushTime(long t) {
263     flushTimeHisto.add(t);
264   }
265 
266   @Override
267   public void updateFlushMemstoreSize(long bytes) {
268     flushMemstoreSizeHisto.add(bytes);
269     flushedMemstoreBytes.incr(bytes);
270   }
271 
272   @Override
273   public void updateFlushOutputSize(long bytes) {
274     flushOutputSizeHisto.add(bytes);
275     flushedOutputBytes.incr(bytes);
276   }
277 
278   @Override
279   public void updateCompactionTime(boolean isMajor, long t) {
280     compactionTimeHisto.add(t);
281     if (isMajor) {
282       majorCompactionTimeHisto.add(t);
283     }
284   }
285 
286   @Override
287   public void updateCompactionInputFileCount(boolean isMajor, long c) {
288     compactionInputFileCountHisto.add(c);
289     if (isMajor) {
290       majorCompactionInputFileCountHisto.add(c);
291     }
292   }
293 
294   @Override
295   public void updateCompactionInputSize(boolean isMajor, long bytes) {
296     compactionInputSizeHisto.add(bytes);
297     compactedInputBytes.incr(bytes);
298     if (isMajor) {
299       majorCompactionInputSizeHisto.add(bytes);
300       majorCompactedInputBytes.incr(bytes);
301     }
302   }
303 
304   @Override
305   public void updateCompactionOutputFileCount(boolean isMajor, long c) {
306     compactionOutputFileCountHisto.add(c);
307     if (isMajor) {
308       majorCompactionOutputFileCountHisto.add(c);
309     }
310   }
311 
312   @Override
313   public void updateCompactionOutputSize(boolean isMajor, long bytes) {
314     compactionOutputSizeHisto.add(bytes);
315     compactedOutputBytes.incr(bytes);
316     if (isMajor) {
317       majorCompactionOutputSizeHisto.add(bytes);
318       majorCompactedOutputBytes.incr(bytes);
319     }
320   }
321 
322   /**
323    * Yes this is a get function that doesn't return anything.  Thanks Hadoop for breaking all
324    * expectations of java programmers.  Instead of returning anything Hadoop metrics expects
325    * getMetrics to push the metrics into the collector.
326    *
327    * @param metricsCollector Collector to accept metrics
328    * @param all              push all or only changed?
329    */
330   @Override
331   public void getMetrics(MetricsCollector metricsCollector, boolean all) {
332 
333     MetricsRecordBuilder mrb = metricsCollector.addRecord(metricsName);
334 
335     // rsWrap can be null because this function is called inside of init.
336     if (rsWrap != null) {
337       mrb.addGauge(Interns.info(REGION_COUNT, REGION_COUNT_DESC), rsWrap.getNumOnlineRegions())
338           .addGauge(Interns.info(STORE_COUNT, STORE_COUNT_DESC), rsWrap.getNumStores())
339           .addGauge(Interns.info(WALFILE_COUNT, WALFILE_COUNT_DESC), rsWrap.getNumWALFiles())
340           .addGauge(Interns.info(WALFILE_SIZE, WALFILE_SIZE_DESC), rsWrap.getWALFileSize())
341           .addGauge(Interns.info(STOREFILE_COUNT, STOREFILE_COUNT_DESC), rsWrap.getNumStoreFiles())
342           .addGauge(Interns.info(MEMSTORE_SIZE, MEMSTORE_SIZE_DESC), rsWrap.getMemstoreSize())
343           .addGauge(Interns.info(STOREFILE_SIZE, STOREFILE_SIZE_DESC), rsWrap.getStoreFileSize())
344           .addGauge(Interns.info(MAX_STORE_FILE_AGE, MAX_STORE_FILE_AGE_DESC),
345               rsWrap.getMaxStoreFileAge())
346           .addGauge(Interns.info(MIN_STORE_FILE_AGE, MIN_STORE_FILE_AGE_DESC),
347               rsWrap.getMinStoreFileAge())
348           .addGauge(Interns.info(AVG_STORE_FILE_AGE, AVG_STORE_FILE_AGE_DESC),
349               rsWrap.getAvgStoreFileAge())
350           .addGauge(Interns.info(NUM_REFERENCE_FILES, NUM_REFERENCE_FILES_DESC),
351               rsWrap.getNumReferenceFiles())
352           .addGauge(Interns.info(RS_START_TIME_NAME, RS_START_TIME_DESC),
353               rsWrap.getStartCode())
354           .addGauge(Interns.info(AVERAGE_REGION_SIZE, AVERAGE_REGION_SIZE_DESC), rsWrap.getAverageRegionSize())
355           .addGauge(Interns.info(READ_REQUEST_RATE, READ_REQUEST_RATE_DESC),
356               rsWrap.getReadRequestsRate())
357           .addGauge(Interns.info(WRITE_REQUEST_RATE, WRITE_REQUEST_RATE_DESC),
358               rsWrap.getWriteRequestsRate())
359           .addCounter(Interns.info(TOTAL_REQUEST_COUNT, TOTAL_REQUEST_COUNT_DESC),
360               rsWrap.getTotalRequestCount())
361           .addCounter(Interns.info(TOTAL_ROW_ACTION_REQUEST_COUNT, TOTAL_ROW_ACTION_REQUEST_COUNT_DESC),
362               rsWrap.getTotalRowActionRequestCount())
363           .addCounter(Interns.info(READ_REQUEST_COUNT, READ_REQUEST_COUNT_DESC),
364               rsWrap.getReadRequestsCount())
365           .addCounter(Interns.info(WRITE_REQUEST_COUNT, WRITE_REQUEST_COUNT_DESC),
366               rsWrap.getWriteRequestsCount())
367           .addCounter(Interns.info(RPC_GET_REQUEST_COUNT, RPC_GET_REQUEST_COUNT_DESC),
368             rsWrap.getRpcGetRequestsCount())
369           .addCounter(Interns.info(RPC_SCAN_REQUEST_COUNT, RPC_SCAN_REQUEST_COUNT_DESC),
370             rsWrap.getRpcScanRequestsCount())
371           .addCounter(Interns.info(RPC_MULTI_REQUEST_COUNT, RPC_MULTI_REQUEST_COUNT_DESC),
372             rsWrap.getRpcMultiRequestsCount())
373           .addCounter(Interns.info(RPC_MUTATE_REQUEST_COUNT, RPC_MUTATE_REQUEST_COUNT_DESC),
374             rsWrap.getRpcMutateRequestsCount())
375           .addCounter(Interns.info(CHECK_MUTATE_FAILED_COUNT, CHECK_MUTATE_FAILED_COUNT_DESC),
376               rsWrap.getCheckAndMutateChecksFailed())
377           .addCounter(Interns.info(CHECK_MUTATE_PASSED_COUNT, CHECK_MUTATE_PASSED_COUNT_DESC),
378               rsWrap.getCheckAndMutateChecksPassed())
379           .addGauge(Interns.info(STOREFILE_INDEX_SIZE, STOREFILE_INDEX_SIZE_DESC),
380               rsWrap.getStoreFileIndexSize())
381           .addGauge(Interns.info(STATIC_INDEX_SIZE, STATIC_INDEX_SIZE_DESC),
382               rsWrap.getTotalStaticIndexSize())
383           .addGauge(Interns.info(STATIC_BLOOM_SIZE, STATIC_BLOOM_SIZE_DESC),
384             rsWrap.getTotalStaticBloomSize())
385           .addGauge(
386             Interns.info(NUMBER_OF_MUTATIONS_WITHOUT_WAL, NUMBER_OF_MUTATIONS_WITHOUT_WAL_DESC),
387               rsWrap.getNumMutationsWithoutWAL())
388           .addGauge(Interns.info(DATA_SIZE_WITHOUT_WAL, DATA_SIZE_WITHOUT_WAL_DESC),
389               rsWrap.getDataInMemoryWithoutWAL())
390           .addGauge(Interns.info(PERCENT_FILES_LOCAL, PERCENT_FILES_LOCAL_DESC),
391               rsWrap.getPercentFileLocal())
392           .addGauge(Interns.info(PERCENT_FILES_LOCAL_SECONDARY_REGIONS,
393               PERCENT_FILES_LOCAL_SECONDARY_REGIONS_DESC),
394               rsWrap.getPercentFileLocalSecondaryRegions())
395           .addGauge(Interns.info(TOTAL_BYTES_READ,
396               TOTAL_BYTES_READ_DESC),
397               rsWrap.getTotalBytesRead())
398           .addGauge(Interns.info(LOCAL_BYTES_READ,
399               LOCAL_BYTES_READ_DESC),
400               rsWrap.getLocalBytesRead())
401           .addGauge(Interns.info(SHORTCIRCUIT_BYTES_READ,
402               SHORTCIRCUIT_BYTES_READ_DESC),
403               rsWrap.getShortCircuitBytesRead())
404           .addGauge(Interns.info(ZEROCOPY_BYTES_READ,
405               ZEROCOPY_BYTES_READ_DESC),
406               rsWrap.getZeroCopyBytesRead())
407           .addGauge(Interns.info(SPLIT_QUEUE_LENGTH, SPLIT_QUEUE_LENGTH_DESC),
408               rsWrap.getSplitQueueSize())
409           .addGauge(Interns.info(COMPACTION_QUEUE_LENGTH, COMPACTION_QUEUE_LENGTH_DESC),
410               rsWrap.getCompactionQueueSize())
411           .addGauge(Interns.info(SMALL_COMPACTION_QUEUE_LENGTH, SMALL_COMPACTION_QUEUE_LENGTH_DESC),
412             rsWrap.getSmallCompactionQueueSize())
413           .addGauge(Interns.info(LARGE_COMPACTION_QUEUE_LENGTH, LARGE_COMPACTION_QUEUE_LENGTH_DESC),
414             rsWrap.getLargeCompactionQueueSize())
415           .addGauge(Interns.info(FLUSH_QUEUE_LENGTH, FLUSH_QUEUE_LENGTH_DESC),
416               rsWrap.getFlushQueueSize())
417 
418           .addGauge(Interns.info(BLOCK_CACHE_FREE_SIZE, BLOCK_CACHE_FREE_DESC),
419               rsWrap.getBlockCacheFreeSize())
420           .addGauge(Interns.info(BLOCK_CACHE_COUNT, BLOCK_CACHE_COUNT_DESC),
421               rsWrap.getBlockCacheCount())
422           .addGauge(Interns.info(BLOCK_CACHE_SIZE, BLOCK_CACHE_SIZE_DESC),
423               rsWrap.getBlockCacheSize())
424           .addCounter(Interns.info(BLOCK_CACHE_HIT_COUNT, BLOCK_CACHE_HIT_COUNT_DESC),
425               rsWrap.getBlockCacheHitCount())
426           .addCounter(Interns.info(BLOCK_CACHE_PRIMARY_HIT_COUNT,
427             BLOCK_CACHE_PRIMARY_HIT_COUNT_DESC), rsWrap.getBlockCachePrimaryHitCount())
428           .addCounter(Interns.info(BLOCK_CACHE_MISS_COUNT, BLOCK_COUNT_MISS_COUNT_DESC),
429               rsWrap.getBlockCacheMissCount())
430           .addCounter(Interns.info(BLOCK_CACHE_PRIMARY_MISS_COUNT,
431             BLOCK_COUNT_PRIMARY_MISS_COUNT_DESC), rsWrap.getBlockCachePrimaryMissCount())
432           .addCounter(Interns.info(BLOCK_CACHE_EVICTION_COUNT, BLOCK_CACHE_EVICTION_COUNT_DESC),
433               rsWrap.getBlockCacheEvictedCount())
434           .addCounter(Interns.info(BLOCK_CACHE_PRIMARY_EVICTION_COUNT,
435             BLOCK_CACHE_PRIMARY_EVICTION_COUNT_DESC), rsWrap.getBlockCachePrimaryEvictedCount())
436           .addGauge(Interns.info(BLOCK_CACHE_HIT_PERCENT, BLOCK_CACHE_HIT_PERCENT_DESC),
437               rsWrap.getBlockCacheHitPercent())
438           .addGauge(Interns.info(BLOCK_CACHE_EXPRESS_HIT_PERCENT,
439               BLOCK_CACHE_EXPRESS_HIT_PERCENT_DESC), rsWrap.getBlockCacheHitCachingPercent())
440           .addCounter(Interns.info(BLOCK_CACHE_FAILED_INSERTION_COUNT,
441               BLOCK_CACHE_FAILED_INSERTION_COUNT_DESC),rsWrap.getBlockCacheFailedInsertions())
442           .addCounter(Interns.info(BLOCK_CACHE_DATA_MISS_COUNT, ""), rsWrap.getDataMissCount())
443           .addCounter(Interns.info(BLOCK_CACHE_LEAF_INDEX_MISS_COUNT, ""),
444               rsWrap.getLeafIndexMissCount())
445           .addCounter(Interns.info(BLOCK_CACHE_BLOOM_CHUNK_MISS_COUNT, ""),
446               rsWrap.getBloomChunkMissCount())
447           .addCounter(Interns.info(BLOCK_CACHE_META_MISS_COUNT, ""), rsWrap.getMetaMissCount())
448           .addCounter(Interns.info(BLOCK_CACHE_ROOT_INDEX_MISS_COUNT, ""),
449               rsWrap.getRootIndexMissCount())
450           .addCounter(Interns.info(BLOCK_CACHE_INTERMEDIATE_INDEX_MISS_COUNT, ""),
451               rsWrap.getIntermediateIndexMissCount())
452           .addCounter(Interns.info(BLOCK_CACHE_FILE_INFO_MISS_COUNT, ""),
453               rsWrap.getFileInfoMissCount())
454           .addCounter(Interns.info(BLOCK_CACHE_GENERAL_BLOOM_META_MISS_COUNT, ""),
455               rsWrap.getGeneralBloomMetaMissCount())
456           .addCounter(Interns.info(BLOCK_CACHE_DELETE_FAMILY_BLOOM_MISS_COUNT, ""),
457               rsWrap.getDeleteFamilyBloomMissCount())
458           .addCounter(Interns.info(BLOCK_CACHE_TRAILER_MISS_COUNT, ""),
459               rsWrap.getTrailerMissCount())
460           .addCounter(Interns.info(BLOCK_CACHE_DATA_HIT_COUNT, ""), rsWrap.getDataHitCount())
461           .addCounter(Interns.info(BLOCK_CACHE_LEAF_INDEX_HIT_COUNT, ""),
462               rsWrap.getLeafIndexHitCount())
463           .addCounter(Interns.info(BLOCK_CACHE_BLOOM_CHUNK_HIT_COUNT, ""),
464               rsWrap.getBloomChunkHitCount())
465           .addCounter(Interns.info(BLOCK_CACHE_META_HIT_COUNT, ""), rsWrap.getMetaHitCount())
466           .addCounter(Interns.info(BLOCK_CACHE_ROOT_INDEX_HIT_COUNT, ""),
467               rsWrap.getRootIndexHitCount())
468           .addCounter(Interns.info(BLOCK_CACHE_INTERMEDIATE_INDEX_HIT_COUNT, ""),
469               rsWrap.getIntermediateIndexHitCount())
470           .addCounter(Interns.info(BLOCK_CACHE_FILE_INFO_HIT_COUNT, ""),
471               rsWrap.getFileInfoHitCount())
472           .addCounter(Interns.info(BLOCK_CACHE_GENERAL_BLOOM_META_HIT_COUNT, ""),
473               rsWrap.getGeneralBloomMetaHitCount())
474           .addCounter(Interns.info(BLOCK_CACHE_DELETE_FAMILY_BLOOM_HIT_COUNT, ""),
475               rsWrap.getDeleteFamilyBloomHitCount())
476           .addCounter(Interns.info(BLOCK_CACHE_TRAILER_HIT_COUNT, ""), rsWrap.getTrailerHitCount())
477           .addGauge(Interns.info(L1_CACHE_HIT_COUNT, L1_CACHE_HIT_COUNT_DESC),
478                   rsWrap.getL1CacheHitCount())
479           .addGauge(Interns.info(L1_CACHE_MISS_COUNT, L1_CACHE_MISS_COUNT_DESC),
480                   rsWrap.getL1CacheMissCount())
481           .addGauge(Interns.info(L1_CACHE_HIT_RATIO, L1_CACHE_HIT_RATIO_DESC),
482                   rsWrap.getL1CacheHitRatio())
483           .addGauge(Interns.info(L1_CACHE_MISS_RATIO, L1_CACHE_MISS_RATIO_DESC),
484                   rsWrap.getL1CacheMissRatio())
485           .addGauge(Interns.info(L2_CACHE_HIT_COUNT, L2_CACHE_HIT_COUNT_DESC),
486                   rsWrap.getL2CacheHitCount())
487           .addGauge(Interns.info(L2_CACHE_MISS_COUNT, L2_CACHE_MISS_COUNT_DESC),
488                   rsWrap.getL2CacheMissCount())
489           .addGauge(Interns.info(L2_CACHE_HIT_RATIO, L2_CACHE_HIT_RATIO_DESC),
490                   rsWrap.getL2CacheHitRatio())
491           .addGauge(Interns.info(L2_CACHE_MISS_RATIO, L2_CACHE_MISS_RATIO_DESC),
492                   rsWrap.getL2CacheMissRatio())
493           .addCounter(Interns.info(UPDATES_BLOCKED_TIME, UPDATES_BLOCKED_DESC),
494               rsWrap.getUpdatesBlockedTime())
495           .addCounter(Interns.info(FLUSHED_CELLS, FLUSHED_CELLS_DESC),
496               rsWrap.getFlushedCellsCount())
497           .addCounter(Interns.info(COMPACTED_CELLS, COMPACTED_CELLS_DESC),
498               rsWrap.getCompactedCellsCount())
499           .addCounter(Interns.info(MAJOR_COMPACTED_CELLS, MAJOR_COMPACTED_CELLS_DESC),
500               rsWrap.getMajorCompactedCellsCount())
501           .addCounter(Interns.info(FLUSHED_CELLS_SIZE, FLUSHED_CELLS_SIZE_DESC),
502               rsWrap.getFlushedCellsSize())
503           .addCounter(Interns.info(COMPACTED_CELLS_SIZE, COMPACTED_CELLS_SIZE_DESC),
504               rsWrap.getCompactedCellsSize())
505           .addCounter(Interns.info(MAJOR_COMPACTED_CELLS_SIZE, MAJOR_COMPACTED_CELLS_SIZE_DESC),
506               rsWrap.getMajorCompactedCellsSize())
507 
508           .addCounter(Interns.info(HEDGED_READS, HEDGED_READS_DESC), rsWrap.getHedgedReadOps())
509           .addCounter(Interns.info(HEDGED_READ_WINS, HEDGED_READ_WINS_DESC),
510               rsWrap.getHedgedReadWins())
511           .addCounter(Interns.info(HEDGED_READ_IN_CUR_THREAD, HEDGED_READ_IN_CUR_THREAD_DESC),
512               rsWrap.getHedgedReadOpsInCurThread())
513 
514           .addCounter(Interns.info(BLOCKED_REQUESTS_COUNT, BLOCKED_REQUESTS_COUNT_DESC),
515             rsWrap.getBlockedRequestsCount())
516           .tag(Interns.info(ZOOKEEPER_QUORUM_NAME, ZOOKEEPER_QUORUM_DESC),
517               rsWrap.getZookeeperQuorum())
518           .tag(Interns.info(SERVER_NAME_NAME, SERVER_NAME_DESC), rsWrap.getServerName())
519           .tag(Interns.info(CLUSTER_ID_NAME, CLUSTER_ID_DESC), rsWrap.getClusterId());
520 
521     }
522 
523     metricsRegistry.snapshot(mrb, all);
524 
525     // source is registered in supers constructor, sometimes called before the whole initialization.
526     if (metricsAdapter != null) {
527       // snapshot MetricRegistry as well
528       metricsAdapter.snapshotAllMetrics(registry, mrb);
529     }
530   }
531 
532   @Override
533   public void incInfoThresholdExceeded(int count) {
534     infoPauseThresholdExceeded.incr(count);
535   }
536 
537   @Override
538   public void incWarnThresholdExceeded(int count) {
539     warnPauseThresholdExceeded.incr(count);
540   }
541 
542   @Override
543   public void updatePauseTimeWithGc(long t) {
544     pausesWithGc.add(t);
545   }
546 
547   @Override
548   public void updatePauseTimeWithoutGc(long t) {
549     pausesWithoutGc.add(t);
550   }
551 
552   @Override
553   public void updateDeleteBatch(long t) {
554     deleteBatchHisto.add(t);
555   }
556 
557   @Override
558   public void updateCheckAndDelete(long t) {
559     checkAndDeleteHisto.add(t);
560   }
561 
562   @Override
563   public void updateCheckAndPut(long t) {
564     checkAndPutHisto.add(t);
565   }
566 
567   @Override
568   public void updatePutBatch(long t) {
569     putBatchHisto.add(t);
570   }
571 }