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