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