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  package org.apache.hadoop.hbase.regionserver;
19  
20  import org.apache.hadoop.conf.Configuration;
21  import org.apache.hadoop.hbase.*;
22  import org.apache.hadoop.hbase.client.*;
23  import org.apache.hadoop.hbase.test.MetricsAssertHelper;
24  import org.apache.hadoop.hbase.testclassification.MediumTests;
25  import org.apache.hadoop.hbase.util.Bytes;
26  import org.apache.hadoop.hbase.util.Threads;
27  import org.apache.log4j.Level;
28  import org.apache.log4j.Logger;
29  import org.junit.AfterClass;
30  import org.junit.BeforeClass;
31  import org.junit.Ignore;
32  import org.junit.Test;
33  import org.junit.experimental.categories.Category;
34  
35  import static org.junit.Assert.*;
36  
37  import java.io.IOException;
38  import java.util.ArrayList;
39  import java.util.List;
40  
41  
42  @Category(MediumTests.class)
43  public class TestRegionServerMetrics {
44    private static MetricsAssertHelper metricsHelper;
45  
46    static {
47      Logger.getLogger("org.apache.hadoop.hbase").setLevel(Level.DEBUG);
48    }
49  
50    private static MiniHBaseCluster cluster;
51    private static HRegionServer rs;
52    private static Configuration conf;
53    private static HBaseTestingUtility TEST_UTIL;
54    private static MetricsRegionServer metricsRegionServer;
55    private static MetricsRegionServerSource serverSource;
56    private static final int NUM_SCAN_NEXT = 30;
57    private static int numScanNext = 0;
58  
59    @BeforeClass
60    public static void startCluster() throws Exception {
61      metricsHelper = CompatibilityFactory.getInstance(MetricsAssertHelper.class);
62      TEST_UTIL = new HBaseTestingUtility();
63      conf = TEST_UTIL.getConfiguration();
64      conf.getLong("hbase.splitlog.max.resubmit", 0);
65      // Make the failure test faster
66      conf.setInt("zookeeper.recovery.retry", 0);
67      conf.setInt(HConstants.REGIONSERVER_INFO_PORT, -1);
68  
69      TEST_UTIL.startMiniCluster(1, 1);
70      cluster = TEST_UTIL.getHBaseCluster();
71  
72      cluster.waitForActiveAndReadyMaster();
73  
74      while (cluster.getLiveRegionServerThreads().size() < 1) {
75        Threads.sleep(100);
76      }
77  
78      rs = cluster.getRegionServer(0);
79      metricsRegionServer = rs.getRegionServerMetrics();
80      serverSource = metricsRegionServer.getMetricsSource();
81    }
82  
83    @AfterClass
84    public static void after() throws Exception {
85      if (TEST_UTIL != null) {
86        TEST_UTIL.shutdownMiniCluster();
87      }
88    }
89  
90    @Test(timeout = 300000)
91    public void testRegionCount() throws Exception {
92      String regionMetricsKey = "regionCount";
93      long regions = metricsHelper.getGaugeLong(regionMetricsKey, serverSource);
94      // Creating a table should add one region
95      TEST_UTIL.createTable(TableName.valueOf("table"), Bytes.toBytes("cf"));
96      metricsHelper.assertGaugeGt(regionMetricsKey, regions, serverSource);
97    }
98  
99    @Test
100   public void testLocalFiles() throws Exception {
101     metricsHelper.assertGauge("percentFilesLocal", 0, serverSource);
102     metricsHelper.assertGauge("percentFilesLocalSecondaryRegions", 0, serverSource);
103   }
104 
105   @Test
106   public void testRequestCount() throws Exception {
107     String tableNameString = "testRequestCount";
108     TableName tName = TableName.valueOf(tableNameString);
109     byte[] cfName = Bytes.toBytes("d");
110     byte[] row = Bytes.toBytes("rk");
111     byte[] qualifier = Bytes.toBytes("qual");
112     byte[] initValue = Bytes.toBytes("Value");
113 
114     TEST_UTIL.createTable(tName, cfName);
115 
116     Connection connection = TEST_UTIL.getConnection();
117     connection.getTable(tName).close(); //wait for the table to come up.
118 
119     // Do a first put to be sure that the connection is established, meta is there and so on.
120     Table table = connection.getTable(tName);
121     Put p = new Put(row);
122     p.add(cfName, qualifier, initValue);
123     table.put(p);
124 
125     metricsRegionServer.getRegionServerWrapper().forceRecompute();
126     long requests = metricsHelper.getCounter("totalRequestCount", serverSource);
127     long readRequests = metricsHelper.getCounter("readRequestCount", serverSource);
128     long writeRequests = metricsHelper.getCounter("writeRequestCount", serverSource);
129 
130     for (int i=0; i< 30; i++) {
131       table.put(p);
132     }
133 
134     metricsRegionServer.getRegionServerWrapper().forceRecompute();
135     metricsHelper.assertCounter("totalRequestCount", requests + 30, serverSource);
136     metricsHelper.assertCounter("readRequestCount", readRequests, serverSource);
137     metricsHelper.assertCounter("writeRequestCount", writeRequests + 30, serverSource);
138 
139     Get g = new Get(row);
140     for (int i=0; i< 10; i++) {
141       table.get(g);
142     }
143 
144     metricsRegionServer.getRegionServerWrapper().forceRecompute();
145     metricsHelper.assertCounter("totalRequestCount", requests + 40, serverSource);
146     metricsHelper.assertCounter("readRequestCount", readRequests + 10, serverSource);
147     metricsHelper.assertCounter("writeRequestCount", writeRequests + 30, serverSource);
148 
149     try (RegionLocator locator = connection.getRegionLocator(tName)) {
150       for ( HRegionLocation location: locator.getAllRegionLocations()) {
151         HRegionInfo i = location.getRegionInfo();
152         MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
153             .getMetrics()
154             .getSource()
155             .getAggregateSource();
156         String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
157             "_table_"+tableNameString +
158             "_region_" + i.getEncodedName()+
159             "_metric";
160         metricsHelper.assertCounter(prefix + "_getNumOps", 10, agg);
161         metricsHelper.assertCounter(prefix + "_mutateCount", 31, agg);
162       }
163     }
164     List<Get> gets = new ArrayList<Get>();
165     for (int i=0; i< 10; i++) {
166       gets.add(new Get(row));
167     }
168     table.get(gets);
169 
170     // By default, master doesn't host meta now.
171     // Adding some meta related requests
172     requests += 3;
173     readRequests ++;
174 
175     metricsRegionServer.getRegionServerWrapper().forceRecompute();
176     metricsHelper.assertCounter("totalRequestCount", requests + 50, serverSource);
177     metricsHelper.assertCounter("readRequestCount", readRequests + 20, serverSource);
178     metricsHelper.assertCounter("writeRequestCount", writeRequests + 30, serverSource);
179 
180     List<Put> puts = new ArrayList<>();
181     for (int i=0; i< 30; i++) {
182       puts.add(p);
183     }
184     table.put(puts);
185 
186     metricsRegionServer.getRegionServerWrapper().forceRecompute();
187     metricsHelper.assertCounter("totalRequestCount", requests + 80, serverSource);
188     metricsHelper.assertCounter("readRequestCount", readRequests + 20, serverSource);
189     metricsHelper.assertCounter("writeRequestCount", writeRequests + 60, serverSource);
190 
191     table.close();
192   }
193 
194   @Test
195   public void testGet() throws Exception {
196     String tableNameString = "testGet";
197     TableName tName = TableName.valueOf(tableNameString);
198     byte[] cfName = Bytes.toBytes("d");
199     byte[] row = Bytes.toBytes("rk");
200     byte[] qualifier = Bytes.toBytes("qual");
201     byte[] initValue = Bytes.toBytes("Value");
202 
203     TEST_UTIL.createTable(tName, cfName);
204 
205     Connection connection = TEST_UTIL.getConnection();
206     connection.getTable(tName).close(); //wait for the table to come up.
207 
208     // Do a first put to be sure that the connection is established, meta is there and so on.
209     Table table = connection.getTable(tName);
210     Put p = new Put(row);
211     p.addColumn(cfName, qualifier, initValue);
212     table.put(p);
213 
214     Get g = new Get(row);
215     for (int i=0; i< 10; i++) {
216       table.get(g);
217     }
218 
219     metricsRegionServer.getRegionServerWrapper().forceRecompute();
220 
221     try (RegionLocator locator = connection.getRegionLocator(tName)) {
222       for ( HRegionLocation location: locator.getAllRegionLocations()) {
223         HRegionInfo i = location.getRegionInfo();
224         MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
225           .getMetrics()
226           .getSource()
227           .getAggregateSource();
228         String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
229           "_table_"+tableNameString +
230           "_region_" + i.getEncodedName()+
231           "_metric";
232         metricsHelper.assertCounter(prefix + "_getSizeNumOps", 10, agg);
233         metricsHelper.assertCounter(prefix + "_getNumOps", 10, agg);
234       }
235       metricsHelper.assertCounterGt("Get_num_ops", 10, serverSource);
236     }
237     table.close();
238   }
239 
240   @Test
241   public void testMutationsWithoutWal() throws Exception {
242     TableName tableName = TableName.valueOf("testMutationsWithoutWal");
243     byte[] cf = Bytes.toBytes("d");
244     byte[] row = Bytes.toBytes("rk");
245     byte[] qualifier = Bytes.toBytes("qual");
246     byte[] val = Bytes.toBytes("Value");
247 
248     metricsRegionServer.getRegionServerWrapper().forceRecompute();
249 
250     TEST_UTIL.createTable(tableName, cf);
251 
252     Table t = new HTable(conf, tableName);
253 
254     Put p = new Put(row);
255     p.add(cf, qualifier, val);
256     p.setDurability(Durability.SKIP_WAL);
257 
258     t.put(p);
259 
260     metricsRegionServer.getRegionServerWrapper().forceRecompute();
261     metricsHelper.assertGauge("mutationsWithoutWALCount", 1, serverSource);
262     long minLength = row.length + cf.length + qualifier.length + val.length;
263     metricsHelper.assertGaugeGt("mutationsWithoutWALSize", minLength, serverSource);
264 
265     t.close();
266   }
267 
268   @Test
269   public void testStoreCount() throws Exception {
270     TableName tableName = TableName.valueOf("testStoreCount");
271     byte[] cf = Bytes.toBytes("d");
272     byte[] row = Bytes.toBytes("rk");
273     byte[] qualifier = Bytes.toBytes("qual");
274     byte[] val = Bytes.toBytes("Value");
275 
276     metricsRegionServer.getRegionServerWrapper().forceRecompute();
277     long stores = metricsHelper.getGaugeLong("storeCount", serverSource);
278     long storeFiles = metricsHelper.getGaugeLong("storeFileCount", serverSource);
279 
280     TEST_UTIL.createTable(tableName, cf);
281 
282     //Force a hfile.
283     Table t = new HTable(conf, tableName);
284     Put p = new Put(row);
285     p.add(cf, qualifier, val);
286     t.put(p);
287     TEST_UTIL.getHBaseAdmin().flush(tableName);
288 
289     metricsRegionServer.getRegionServerWrapper().forceRecompute();
290     metricsHelper.assertGauge("storeCount", stores +1, serverSource);
291     metricsHelper.assertGauge("storeFileCount", storeFiles + 1, serverSource);
292 
293     t.close();
294   }
295 
296   @Test
297   public void testStoreFileAge() throws Exception {
298     TableName tableName = TableName.valueOf("testStoreFileAge");
299     byte[] cf = Bytes.toBytes("d");
300     byte[] row = Bytes.toBytes("rk");
301     byte[] qualifier = Bytes.toBytes("qual");
302     byte[] val = Bytes.toBytes("Value");
303 
304     //Force a hfile.
305     Table t = TEST_UTIL.createTable(tableName, cf);
306     Put p = new Put(row);
307     p.addColumn(cf, qualifier, val);
308     t.put(p);
309     TEST_UTIL.getHBaseAdmin().flush(tableName);
310 
311     metricsRegionServer.getRegionServerWrapper().forceRecompute();
312     assertTrue(metricsHelper.getGaugeLong("maxStoreFileAge", serverSource) > 0);
313     assertTrue(metricsHelper.getGaugeLong("minStoreFileAge", serverSource) >= 0);
314     assertTrue(metricsHelper.getGaugeLong("avgStoreFileAge", serverSource) > 0);
315 
316     t.close();
317   }
318 
319   @Test
320   public void testCheckAndPutCount() throws Exception {
321     String tableNameString = "testCheckAndPutCount";
322     TableName tableName = TableName.valueOf(tableNameString);
323     byte[] cf = Bytes.toBytes("d");
324     byte[] row = Bytes.toBytes("rk");
325     byte[] qualifier = Bytes.toBytes("qual");
326     byte[] valOne = Bytes.toBytes("Value");
327     byte[] valTwo = Bytes.toBytes("ValueTwo");
328     byte[] valThree = Bytes.toBytes("ValueThree");
329 
330     TEST_UTIL.createTable(tableName, cf);
331     Table t = new HTable(conf, tableName);
332     Put p = new Put(row);
333     p.add(cf, qualifier, valOne);
334     t.put(p);
335 
336     Put pTwo = new Put(row);
337     pTwo.add(cf, qualifier, valTwo);
338     t.checkAndPut(row, cf, qualifier, valOne, pTwo);
339 
340     Put pThree = new Put(row);
341     pThree.add(cf, qualifier, valThree);
342     t.checkAndPut(row, cf, qualifier, valOne, pThree);
343 
344     metricsRegionServer.getRegionServerWrapper().forceRecompute();
345     metricsHelper.assertCounter("checkMutateFailedCount", 1, serverSource);
346     metricsHelper.assertCounter("checkMutatePassedCount", 1, serverSource);
347 
348     t.close();
349   }
350 
351   @Test
352   public void testIncrement() throws Exception {
353     String tableNameString = "testIncrement";
354     TableName tableName = TableName.valueOf(tableNameString);
355     byte[] cf = Bytes.toBytes("d");
356     byte[] row = Bytes.toBytes("rk");
357     byte[] qualifier = Bytes.toBytes("qual");
358     byte[] val = Bytes.toBytes(0l);
359 
360 
361     TEST_UTIL.createTable(tableName, cf);
362     Table t = new HTable(conf, tableName);
363 
364     Put p = new Put(row);
365     p.add(cf, qualifier, val);
366     t.put(p);
367 
368     for(int count = 0; count< 13; count++) {
369       Increment inc = new Increment(row);
370       inc.addColumn(cf, qualifier, 100);
371       t.increment(inc);
372     }
373 
374     metricsRegionServer.getRegionServerWrapper().forceRecompute();
375     metricsHelper.assertCounter("incrementNumOps", 13, serverSource);
376 
377     t.close();
378   }
379 
380   @Test
381   public void testAppend() throws Exception {
382     String tableNameString = "testAppend";
383     TableName tableName = TableName.valueOf(tableNameString);
384     byte[] cf = Bytes.toBytes("d");
385     byte[] row = Bytes.toBytes("rk");
386     byte[] qualifier = Bytes.toBytes("qual");
387     byte[] val = Bytes.toBytes("One");
388 
389 
390     TEST_UTIL.createTable(tableName, cf);
391     Table t = new HTable(conf, tableName);
392 
393     Put p = new Put(row);
394     p.add(cf, qualifier, val);
395     t.put(p);
396 
397     for(int count = 0; count< 73; count++) {
398       Append append = new Append(row);
399       append.add(cf, qualifier, Bytes.toBytes(",Test"));
400       t.append(append);
401     }
402 
403     metricsRegionServer.getRegionServerWrapper().forceRecompute();
404     metricsHelper.assertCounter("appendNumOps", 73, serverSource);
405 
406     t.close();
407   }
408 
409   @Test
410   public void testScanSize() throws IOException {
411     String tableNameString = "testScanSize";
412     TableName tableName = TableName.valueOf(tableNameString);
413     byte[] cf = Bytes.toBytes("d");
414     byte[] qualifier = Bytes.toBytes("qual");
415     byte[] val = Bytes.toBytes("One");
416 
417     List<Put> puts = new ArrayList<>();
418     for (int insertCount =0; insertCount < 100; insertCount++) {
419       Put p = new Put(Bytes.toBytes("" + insertCount + "row"));
420       p.add(cf, qualifier, val);
421       puts.add(p);
422     }
423     try (HTable t = TEST_UTIL.createTable(tableName, cf)) {
424       t.put(puts);
425 
426       Scan s = new Scan();
427       s.setBatch(1);
428       s.setCaching(1);
429       ResultScanner resultScanners = t.getScanner(s);
430 
431       for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) {
432         Result result = resultScanners.next();
433         assertNotNull(result);
434         assertEquals(1, result.size());
435       }
436     }
437     numScanNext += NUM_SCAN_NEXT;
438     try (RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName)) {
439       for ( HRegionLocation location: locator.getAllRegionLocations()) {
440         HRegionInfo i = location.getRegionInfo();
441         MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
442             .getMetrics()
443             .getSource()
444             .getAggregateSource();
445         String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
446             "_table_"+tableNameString +
447             "_region_" + i.getEncodedName()+
448             "_metric";
449         metricsHelper.assertCounter(prefix + "_scanSizeNumOps", NUM_SCAN_NEXT, agg);
450       }
451       metricsHelper.assertCounterGt("ScanSize_num_ops", numScanNext, serverSource);
452     }
453     try (Admin admin = TEST_UTIL.getHBaseAdmin()) {
454       admin.disableTable(tableName);
455       admin.deleteTable(tableName);
456     }
457   }
458 
459   @Test
460   public void testScanTime() throws IOException {
461     String tableNameString = "testScanTime";
462     TableName tableName = TableName.valueOf(tableNameString);
463     byte[] cf = Bytes.toBytes("d");
464     byte[] qualifier = Bytes.toBytes("qual");
465     byte[] val = Bytes.toBytes("One");
466 
467     List<Put> puts = new ArrayList<>();
468     for (int insertCount =0; insertCount < 100; insertCount++) {
469       Put p = new Put(Bytes.toBytes("" + insertCount + "row"));
470       p.addColumn(cf, qualifier, val);
471       puts.add(p);
472     }
473     try (Table t = TEST_UTIL.createTable(tableName, cf)) {
474       t.put(puts);
475 
476       Scan s = new Scan();
477       s.setBatch(1);
478       s.setCaching(1);
479       ResultScanner resultScanners = t.getScanner(s);
480 
481       for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) {
482         Result result = resultScanners.next();
483         assertNotNull(result);
484         assertEquals(1, result.size());
485       }
486     }
487     numScanNext += NUM_SCAN_NEXT;
488     try (RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName)) {
489       for ( HRegionLocation location: locator.getAllRegionLocations()) {
490         HRegionInfo i = location.getRegionInfo();
491         MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
492           .getMetrics()
493           .getSource()
494           .getAggregateSource();
495         String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
496           "_table_"+tableNameString +
497           "_region_" + i.getEncodedName()+
498           "_metric";
499         metricsHelper.assertCounter(prefix + "_scanTimeNumOps", NUM_SCAN_NEXT, agg);
500       }
501       metricsHelper.assertCounterGt("ScanTime_num_ops", numScanNext, serverSource);
502     }
503     try (Admin admin = TEST_UTIL.getHBaseAdmin()) {
504       admin.disableTable(tableName);
505       admin.deleteTable(tableName);
506     }
507   }
508 
509   @Test
510   public void testScanSizeForSmallScan() throws IOException {
511     String tableNameString = "testScanSizeSmall";
512     TableName tableName = TableName.valueOf(tableNameString);
513     byte[] cf = Bytes.toBytes("d");
514     byte[] qualifier = Bytes.toBytes("qual");
515     byte[] val = Bytes.toBytes("One");
516 
517     List<Put> puts = new ArrayList<>();
518     for (int insertCount =0; insertCount < 100; insertCount++) {
519       Put p = new Put(Bytes.toBytes("" + insertCount + "row"));
520       p.add(cf, qualifier, val);
521       puts.add(p);
522     }
523     try (HTable t = TEST_UTIL.createTable(tableName, cf)) {
524       t.put(puts);
525 
526       Scan s = new Scan();
527       s.setSmall(true);
528       s.setCaching(1);
529       ResultScanner resultScanners = t.getScanner(s);
530 
531       for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) {
532         Result result = resultScanners.next();
533         assertNotNull(result);
534         assertEquals(1, result.size());
535       }
536     }
537     numScanNext += NUM_SCAN_NEXT;
538     try (RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName)) {
539       int cnt = 0;
540       for (HRegionLocation location: locator.getAllRegionLocations()) {
541         cnt++;
542         HRegionInfo i = location.getRegionInfo();
543         MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
544             .getMetrics()
545             .getSource()
546             .getAggregateSource();
547         String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
548             "_table_"+tableNameString +
549             "_region_" + i.getEncodedName()+
550             "_metric";
551         metricsHelper.assertCounter(prefix + "_scanSizeNumOps", NUM_SCAN_NEXT, agg);
552       }
553       metricsHelper.assertCounterGt("ScanSize_num_ops", numScanNext, serverSource);
554     }
555     try (Admin admin = TEST_UTIL.getHBaseAdmin()) {
556       admin.disableTable(tableName);
557       admin.deleteTable(tableName);
558     }
559   }
560 
561   @Test
562   @Ignore
563   public void testRangeCountMetrics() throws Exception {
564     String tableNameString = "testRangeCountMetrics";
565     final long[] timeranges =
566         { 1, 3, 10, 30, 100, 300, 1000, 3000, 10000, 30000, 60000, 120000, 300000, 600000 };
567     final String timeRangeType = "TimeRangeCount";
568     final String timeRangeMetricName = "Mutate";
569     boolean timeRangeCountUpdated = false;
570 
571     TableName tName = TableName.valueOf(tableNameString);
572     byte[] cfName = Bytes.toBytes("d");
573     byte[] row = Bytes.toBytes("rk");
574     byte[] qualifier = Bytes.toBytes("qual");
575     byte[] initValue = Bytes.toBytes("Value");
576 
577     TEST_UTIL.createTable(tName, cfName);
578 
579     Connection connection = TEST_UTIL.getConnection();
580     connection.getTable(tName).close(); // wait for the table to come up.
581 
582     // Do a first put to be sure that the connection is established, meta is there and so on.
583     Table table = connection.getTable(tName);
584     Put p = new Put(row);
585     p.addColumn(cfName, qualifier, initValue);
586     table.put(p);
587 
588     // do some puts and gets
589     for (int i = 0; i < 10; i++) {
590       table.put(p);
591     }
592 
593     Get g = new Get(row);
594     for (int i = 0; i < 10; i++) {
595       table.get(g);
596     }
597 
598     metricsRegionServer.getRegionServerWrapper().forceRecompute();
599 
600     // Check some time range counters were updated
601     long prior = 0;
602 
603     String dynamicMetricName;
604     for (int i = 0; i < timeranges.length; i++) {
605       dynamicMetricName =
606           timeRangeMetricName + "_" + timeRangeType + "_" + prior + "-" + timeranges[i];
607       if (metricsHelper.checkCounterExists(dynamicMetricName, serverSource)) {
608         long count = metricsHelper.getGaugeLong(dynamicMetricName, serverSource);
609         if (count > 0) {
610           timeRangeCountUpdated = true;
611           break;
612         }
613       }
614       prior = timeranges[i];
615     }
616     dynamicMetricName =
617         timeRangeMetricName + "_" + timeRangeType + "_" + timeranges[timeranges.length - 1] + "-inf";
618     if (metricsHelper.checkCounterExists(dynamicMetricName, serverSource)) {
619       long count = metricsHelper.getCounter(dynamicMetricName, serverSource);
620       if (count > 0) {
621         timeRangeCountUpdated = true;
622       }
623     }
624     assertEquals(true, timeRangeCountUpdated);
625 
626     table.close();
627   }
628 
629   @Test
630   public void testAverageRegionSize() throws Exception {
631     TableName tableName = TableName.valueOf("testAverageRegionSize");
632     byte[] cf = Bytes.toBytes("d");
633     byte[] row = Bytes.toBytes("rk");
634     byte[] qualifier = Bytes.toBytes("qual");
635     byte[] val = Bytes.toBytes("Value");
636 
637     //Force a hfile.
638     Table t = TEST_UTIL.createTable(tableName, cf);
639     Put p = new Put(row);
640     p.addColumn(cf, qualifier, val);
641     t.put(p);
642     TEST_UTIL.getHBaseAdmin().flush(tableName);
643 
644     metricsRegionServer.getRegionServerWrapper().forceRecompute();
645     assertTrue(metricsHelper.getGaugeDouble("averageRegionSize", serverSource) > 0.0);
646 
647     t.close();
648   }
649 
650   @Test
651   public void testMobMetrics() throws IOException, InterruptedException {
652     String tableNameString = "testMobMetrics";
653     TableName tableName = TableName.valueOf(tableNameString);
654     byte[] cf = Bytes.toBytes("d");
655     byte[] qualifier = Bytes.toBytes("qual");
656     byte[] val = Bytes.toBytes("mobdata");
657     int numHfiles = conf.getInt("hbase.hstore.compactionThreshold", 3) - 1;
658     HTableDescriptor htd = new HTableDescriptor(tableName);
659     HColumnDescriptor hcd = new HColumnDescriptor(cf);
660     hcd.setMobEnabled(true);
661     hcd.setMobThreshold(0);
662     htd.addFamily(hcd);
663     HBaseAdmin admin = new HBaseAdmin(conf);
664     HTable t = TEST_UTIL.createTable(htd, new byte[0][0], conf);
665     Region region = rs.getOnlineRegions(tableName).get(0);
666     t.setAutoFlush(true, true);
667     for (int insertCount = 0; insertCount < numHfiles; insertCount++) {
668       Put p = new Put(Bytes.toBytes(insertCount));
669       p.add(cf, qualifier, val);
670       t.put(p);
671       admin.flush(tableName);
672     }
673     metricsRegionServer.getRegionServerWrapper().forceRecompute();
674     metricsHelper.assertCounter("mobFlushCount", numHfiles, serverSource);
675     Scan scan = new Scan(Bytes.toBytes(0), Bytes.toBytes(2));
676     ResultScanner scanner = t.getScanner(scan);
677     scanner.next(100);
678     numScanNext++;  // this is an ugly construct
679     scanner.close();
680     metricsRegionServer.getRegionServerWrapper().forceRecompute();
681     metricsHelper.assertCounter("mobScanCellsCount", 2, serverSource);
682     region.getTableDesc().getFamily(cf).setMobThreshold(100);
683     ((HRegion)region).initialize();
684     region.compact(true);
685     metricsRegionServer.getRegionServerWrapper().forceRecompute();
686     metricsHelper.assertCounter("cellsCountCompactedFromMob", numHfiles,
687         serverSource);
688     metricsHelper.assertCounter("cellsCountCompactedToMob", 0, serverSource);
689     scanner = t.getScanner(scan);
690     scanner.next(100);
691     numScanNext++;  // this is an ugly construct
692     metricsRegionServer.getRegionServerWrapper().forceRecompute();
693     // metrics are reset by the region initialization
694     metricsHelper.assertCounter("mobScanCellsCount", 0, serverSource);
695     for (int insertCount = numHfiles;
696         insertCount < 2 * numHfiles - 1; insertCount++) {
697       Put p = new Put(Bytes.toBytes(insertCount));
698       p.add(cf, qualifier, val);
699       t.put(p);
700       admin.flush(tableName);
701     }
702     region.getTableDesc().getFamily(cf).setMobThreshold(0);
703     ((HRegion)region).initialize();
704     region.compact(true);
705     metricsRegionServer.getRegionServerWrapper().forceRecompute();
706     // metrics are reset by the region initialization
707     metricsHelper.assertCounter("cellsCountCompactedFromMob", 0, serverSource);
708     metricsHelper.assertCounter("cellsCountCompactedToMob", 2 * numHfiles - 1,
709         serverSource);
710     t.close();
711     admin.close();
712   }
713 }