1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
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
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();
118
119
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
171
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();
207
208
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
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
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();
581
582
583 Table table = connection.getTable(tName);
584 Put p = new Put(row);
585 p.addColumn(cfName, qualifier, initValue);
586 table.put(p);
587
588
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
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
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++;
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++;
692 metricsRegionServer.getRegionServerWrapper().forceRecompute();
693
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
707 metricsHelper.assertCounter("cellsCountCompactedFromMob", 0, serverSource);
708 metricsHelper.assertCounter("cellsCountCompactedToMob", 2 * numHfiles - 1,
709 serverSource);
710 t.close();
711 admin.close();
712 }
713 }