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("hbase.regionserver.periodicmemstoreflusher.rangeofdelayseconds", 4*60);
68 conf.setInt(HConstants.REGIONSERVER_INFO_PORT, -1);
69
70 TEST_UTIL.startMiniCluster(1, 1);
71 cluster = TEST_UTIL.getHBaseCluster();
72
73 cluster.waitForActiveAndReadyMaster();
74
75 while (cluster.getLiveRegionServerThreads().size() < 1) {
76 Threads.sleep(100);
77 }
78
79 rs = cluster.getRegionServer(0);
80 metricsRegionServer = rs.getRegionServerMetrics();
81 serverSource = metricsRegionServer.getMetricsSource();
82 }
83
84 @AfterClass
85 public static void after() throws Exception {
86 if (TEST_UTIL != null) {
87 TEST_UTIL.shutdownMiniCluster();
88 }
89 }
90
91 @Test(timeout = 300000)
92 public void testRegionCount() throws Exception {
93 String regionMetricsKey = "regionCount";
94 long regions = metricsHelper.getGaugeLong(regionMetricsKey, serverSource);
95
96 TEST_UTIL.createTable(TableName.valueOf("table"), Bytes.toBytes("cf"));
97 metricsHelper.assertGaugeGt(regionMetricsKey, regions, serverSource);
98 }
99
100 @Test
101 public void testLocalFiles() throws Exception {
102 metricsHelper.assertGauge("percentFilesLocal", 0, serverSource);
103 metricsHelper.assertGauge("percentFilesLocalSecondaryRegions", 0, serverSource);
104 }
105
106 @Test
107 public void testRequestCount() throws Exception {
108 String tableNameString = "testRequestCount";
109 TableName tName = TableName.valueOf(tableNameString);
110 byte[] cfName = Bytes.toBytes("d");
111 byte[] row = Bytes.toBytes("rk");
112 byte[] qualifier = Bytes.toBytes("qual");
113 byte[] initValue = Bytes.toBytes("Value");
114
115 TEST_UTIL.createTable(tName, cfName);
116
117 Connection connection = TEST_UTIL.getConnection();
118 connection.getTable(tName).close();
119
120
121 Table table = connection.getTable(tName);
122 Put p = new Put(row);
123 p.add(cfName, qualifier, initValue);
124 table.put(p);
125
126 metricsRegionServer.getRegionServerWrapper().forceRecompute();
127 long requests = metricsHelper.getCounter("totalRequestCount", serverSource);
128 long readRequests = metricsHelper.getCounter("readRequestCount", serverSource);
129 long writeRequests = metricsHelper.getCounter("writeRequestCount", serverSource);
130
131 for (int i=0; i< 30; i++) {
132 table.put(p);
133 }
134
135 metricsRegionServer.getRegionServerWrapper().forceRecompute();
136 metricsHelper.assertCounter("totalRequestCount", requests + 30, serverSource);
137 metricsHelper.assertCounter("readRequestCount", readRequests, serverSource);
138 metricsHelper.assertCounter("writeRequestCount", writeRequests + 30, serverSource);
139
140 Get g = new Get(row);
141 for (int i=0; i< 10; i++) {
142 table.get(g);
143 }
144
145 metricsRegionServer.getRegionServerWrapper().forceRecompute();
146 metricsHelper.assertCounter("totalRequestCount", requests + 40, serverSource);
147 metricsHelper.assertCounter("readRequestCount", readRequests + 10, serverSource);
148 metricsHelper.assertCounter("writeRequestCount", writeRequests + 30, serverSource);
149
150 try (RegionLocator locator = connection.getRegionLocator(tName)) {
151 for ( HRegionLocation location: locator.getAllRegionLocations()) {
152 HRegionInfo i = location.getRegionInfo();
153 MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
154 .getMetrics()
155 .getSource()
156 .getAggregateSource();
157 String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
158 "_table_"+tableNameString +
159 "_region_" + i.getEncodedName()+
160 "_metric";
161 metricsHelper.assertCounter(prefix + "_getCount", 10, agg);
162 metricsHelper.assertCounter(prefix + "_mutateCount", 31, agg);
163 }
164 }
165 List<Get> gets = new ArrayList<Get>();
166 for (int i=0; i< 10; i++) {
167 gets.add(new Get(row));
168 }
169 table.get(gets);
170
171
172
173 requests += 3;
174 readRequests ++;
175
176 metricsRegionServer.getRegionServerWrapper().forceRecompute();
177 metricsHelper.assertCounter("totalRequestCount", requests + 50, serverSource);
178 metricsHelper.assertCounter("readRequestCount", readRequests + 20, serverSource);
179 metricsHelper.assertCounter("writeRequestCount", writeRequests + 30, serverSource);
180
181 List<Put> puts = new ArrayList<>();
182 for (int i=0; i< 30; i++) {
183 puts.add(p);
184 }
185 table.put(puts);
186
187 metricsRegionServer.getRegionServerWrapper().forceRecompute();
188 metricsHelper.assertCounter("totalRequestCount", requests + 80, serverSource);
189 metricsHelper.assertCounter("readRequestCount", readRequests + 20, serverSource);
190 metricsHelper.assertCounter("writeRequestCount", writeRequests + 60, serverSource);
191
192 table.close();
193 }
194
195 @Test
196 public void testGet() throws Exception {
197 String tableNameString = "testGet";
198 TableName tName = TableName.valueOf(tableNameString);
199 byte[] cfName = Bytes.toBytes("d");
200 byte[] row = Bytes.toBytes("rk");
201 byte[] qualifier = Bytes.toBytes("qual");
202 byte[] initValue = Bytes.toBytes("Value");
203
204 TEST_UTIL.createTable(tName, cfName);
205
206 Connection connection = TEST_UTIL.getConnection();
207 connection.getTable(tName).close();
208
209
210 Table table = connection.getTable(tName);
211 Put p = new Put(row);
212 p.addColumn(cfName, qualifier, initValue);
213 table.put(p);
214
215 Get g = new Get(row);
216 for (int i=0; i< 10; i++) {
217 table.get(g);
218 }
219
220 metricsRegionServer.getRegionServerWrapper().forceRecompute();
221
222 try (RegionLocator locator = connection.getRegionLocator(tName)) {
223 for ( HRegionLocation location: locator.getAllRegionLocations()) {
224 HRegionInfo i = location.getRegionInfo();
225 MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
226 .getMetrics()
227 .getSource()
228 .getAggregateSource();
229 String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
230 "_table_"+tableNameString +
231 "_region_" + i.getEncodedName()+
232 "_metric";
233 metricsHelper.assertCounter(prefix + "_getCount", 10, agg);
234 metricsHelper.assertCounter(prefix + "_getCount", 10, agg);
235 }
236 metricsHelper.assertCounterGt("Get_num_ops", 10, serverSource);
237 }
238 table.close();
239 }
240
241 @Test
242 public void testMutationsWithoutWal() throws Exception {
243 TableName tableName = TableName.valueOf("testMutationsWithoutWal");
244 byte[] cf = Bytes.toBytes("d");
245 byte[] row = Bytes.toBytes("rk");
246 byte[] qualifier = Bytes.toBytes("qual");
247 byte[] val = Bytes.toBytes("Value");
248
249 metricsRegionServer.getRegionServerWrapper().forceRecompute();
250
251 TEST_UTIL.createTable(tableName, cf);
252
253 Table t = new HTable(conf, tableName);
254
255 Put p = new Put(row);
256 p.add(cf, qualifier, val);
257 p.setDurability(Durability.SKIP_WAL);
258
259 t.put(p);
260
261 metricsRegionServer.getRegionServerWrapper().forceRecompute();
262 metricsHelper.assertGauge("mutationsWithoutWALCount", 1, serverSource);
263 long minLength = row.length + cf.length + qualifier.length + val.length;
264 metricsHelper.assertGaugeGt("mutationsWithoutWALSize", minLength, serverSource);
265
266 t.close();
267 }
268
269 @Test
270 public void testStoreCount() throws Exception {
271 TableName tableName = TableName.valueOf("testStoreCount");
272 byte[] cf = Bytes.toBytes("d");
273 byte[] row = Bytes.toBytes("rk");
274 byte[] qualifier = Bytes.toBytes("qual");
275 byte[] val = Bytes.toBytes("Value");
276
277 metricsRegionServer.getRegionServerWrapper().forceRecompute();
278 long stores = metricsHelper.getGaugeLong("storeCount", serverSource);
279 long storeFiles = metricsHelper.getGaugeLong("storeFileCount", serverSource);
280
281 TEST_UTIL.createTable(tableName, cf);
282
283
284 Table t = new HTable(conf, tableName);
285 Put p = new Put(row);
286 p.add(cf, qualifier, val);
287 t.put(p);
288 TEST_UTIL.getHBaseAdmin().flush(tableName);
289
290 metricsRegionServer.getRegionServerWrapper().forceRecompute();
291 metricsHelper.assertGauge("storeCount", stores +1, serverSource);
292 metricsHelper.assertGauge("storeFileCount", storeFiles + 1, serverSource);
293
294 t.close();
295 }
296
297 @Test
298 public void testStoreFileAge() throws Exception {
299 TableName tableName = TableName.valueOf("testStoreFileAge");
300 byte[] cf = Bytes.toBytes("d");
301 byte[] row = Bytes.toBytes("rk");
302 byte[] qualifier = Bytes.toBytes("qual");
303 byte[] val = Bytes.toBytes("Value");
304
305
306 Table t = TEST_UTIL.createTable(tableName, cf);
307 Put p = new Put(row);
308 p.addColumn(cf, qualifier, val);
309 t.put(p);
310 TEST_UTIL.getHBaseAdmin().flush(tableName);
311
312 metricsRegionServer.getRegionServerWrapper().forceRecompute();
313 assertTrue(metricsHelper.getGaugeLong("maxStoreFileAge", serverSource) > 0);
314 assertTrue(metricsHelper.getGaugeLong("minStoreFileAge", serverSource) > 0);
315 assertTrue(metricsHelper.getGaugeLong("avgStoreFileAge", serverSource) > 0);
316
317 t.close();
318 }
319
320 @Test
321 public void testCheckAndPutCount() throws Exception {
322 String tableNameString = "testCheckAndPutCount";
323 TableName tableName = TableName.valueOf(tableNameString);
324 byte[] cf = Bytes.toBytes("d");
325 byte[] row = Bytes.toBytes("rk");
326 byte[] qualifier = Bytes.toBytes("qual");
327 byte[] valOne = Bytes.toBytes("Value");
328 byte[] valTwo = Bytes.toBytes("ValueTwo");
329 byte[] valThree = Bytes.toBytes("ValueThree");
330
331 TEST_UTIL.createTable(tableName, cf);
332 Table t = new HTable(conf, tableName);
333 Put p = new Put(row);
334 p.add(cf, qualifier, valOne);
335 t.put(p);
336
337 Put pTwo = new Put(row);
338 pTwo.add(cf, qualifier, valTwo);
339 t.checkAndPut(row, cf, qualifier, valOne, pTwo);
340
341 Put pThree = new Put(row);
342 pThree.add(cf, qualifier, valThree);
343 t.checkAndPut(row, cf, qualifier, valOne, pThree);
344
345 metricsRegionServer.getRegionServerWrapper().forceRecompute();
346 metricsHelper.assertCounter("checkMutateFailedCount", 1, serverSource);
347 metricsHelper.assertCounter("checkMutatePassedCount", 1, serverSource);
348
349 t.close();
350 }
351
352 @Test
353 public void testIncrement() throws Exception {
354 String tableNameString = "testIncrement";
355 TableName tableName = TableName.valueOf(tableNameString);
356 byte[] cf = Bytes.toBytes("d");
357 byte[] row = Bytes.toBytes("rk");
358 byte[] qualifier = Bytes.toBytes("qual");
359 byte[] val = Bytes.toBytes(0l);
360
361
362 TEST_UTIL.createTable(tableName, cf);
363 Table t = new HTable(conf, tableName);
364
365 Put p = new Put(row);
366 p.add(cf, qualifier, val);
367 t.put(p);
368
369 for(int count = 0; count< 13; count++) {
370 Increment inc = new Increment(row);
371 inc.addColumn(cf, qualifier, 100);
372 t.increment(inc);
373 }
374
375 metricsRegionServer.getRegionServerWrapper().forceRecompute();
376 metricsHelper.assertCounter("incrementNumOps", 13, serverSource);
377
378 t.close();
379 }
380
381 @Test
382 public void testAppend() throws Exception {
383 String tableNameString = "testAppend";
384 TableName tableName = TableName.valueOf(tableNameString);
385 byte[] cf = Bytes.toBytes("d");
386 byte[] row = Bytes.toBytes("rk");
387 byte[] qualifier = Bytes.toBytes("qual");
388 byte[] val = Bytes.toBytes("One");
389
390
391 TEST_UTIL.createTable(tableName, cf);
392 Table t = new HTable(conf, tableName);
393
394 Put p = new Put(row);
395 p.add(cf, qualifier, val);
396 t.put(p);
397
398 for(int count = 0; count< 73; count++) {
399 Append append = new Append(row);
400 append.add(cf, qualifier, Bytes.toBytes(",Test"));
401 t.append(append);
402 }
403
404 metricsRegionServer.getRegionServerWrapper().forceRecompute();
405 metricsHelper.assertCounter("appendNumOps", 73, serverSource);
406
407 t.close();
408 }
409
410 @Test
411 public void testScanSize() throws IOException {
412 String tableNameString = "testScanSize";
413 TableName tableName = TableName.valueOf(tableNameString);
414 byte[] cf = Bytes.toBytes("d");
415 byte[] qualifier = Bytes.toBytes("qual");
416 byte[] val = Bytes.toBytes("One");
417
418 List<Put> puts = new ArrayList<>();
419 for (int insertCount =0; insertCount < 100; insertCount++) {
420 Put p = new Put(Bytes.toBytes("" + insertCount + "row"));
421 p.add(cf, qualifier, val);
422 puts.add(p);
423 }
424 try (HTable t = TEST_UTIL.createTable(tableName, cf)) {
425 t.put(puts);
426
427 Scan s = new Scan();
428 s.setBatch(1);
429 s.setCaching(1);
430 ResultScanner resultScanners = t.getScanner(s);
431
432 for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) {
433 Result result = resultScanners.next();
434 assertNotNull(result);
435 assertEquals(1, result.size());
436 }
437 }
438 numScanNext += NUM_SCAN_NEXT;
439 try (RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName)) {
440 for ( HRegionLocation location: locator.getAllRegionLocations()) {
441 HRegionInfo i = location.getRegionInfo();
442 MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
443 .getMetrics()
444 .getSource()
445 .getAggregateSource();
446 String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
447 "_table_"+tableNameString +
448 "_region_" + i.getEncodedName()+
449 "_metric";
450 metricsHelper.assertCounter(prefix + "_scanCount", NUM_SCAN_NEXT, agg);
451 }
452 metricsHelper.assertCounterGt("ScanSize_num_ops", numScanNext, serverSource);
453 }
454 try (Admin admin = TEST_UTIL.getHBaseAdmin()) {
455 admin.disableTable(tableName);
456 admin.deleteTable(tableName);
457 }
458 }
459
460 @Test
461 public void testScanTime() throws IOException {
462 String tableNameString = "testScanTime";
463 TableName tableName = TableName.valueOf(tableNameString);
464 byte[] cf = Bytes.toBytes("d");
465 byte[] qualifier = Bytes.toBytes("qual");
466 byte[] val = Bytes.toBytes("One");
467
468 List<Put> puts = new ArrayList<>();
469 for (int insertCount =0; insertCount < 100; insertCount++) {
470 Put p = new Put(Bytes.toBytes("" + insertCount + "row"));
471 p.addColumn(cf, qualifier, val);
472 puts.add(p);
473 }
474 try (Table t = TEST_UTIL.createTable(tableName, cf)) {
475 t.put(puts);
476
477 Scan s = new Scan();
478 s.setBatch(1);
479 s.setCaching(1);
480 ResultScanner resultScanners = t.getScanner(s);
481
482 for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) {
483 Result result = resultScanners.next();
484 assertNotNull(result);
485 assertEquals(1, result.size());
486 }
487 }
488 numScanNext += NUM_SCAN_NEXT;
489 try (RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName)) {
490 for ( HRegionLocation location: locator.getAllRegionLocations()) {
491 HRegionInfo i = location.getRegionInfo();
492 MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
493 .getMetrics()
494 .getSource()
495 .getAggregateSource();
496 String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
497 "_table_"+tableNameString +
498 "_region_" + i.getEncodedName()+
499 "_metric";
500 metricsHelper.assertCounter(prefix + "_scanCount", NUM_SCAN_NEXT, agg);
501 }
502 metricsHelper.assertCounterGt("ScanTime_num_ops", numScanNext, serverSource);
503 }
504 try (Admin admin = TEST_UTIL.getHBaseAdmin()) {
505 admin.disableTable(tableName);
506 admin.deleteTable(tableName);
507 }
508 }
509
510 @Test
511 public void testScanSizeForSmallScan() throws IOException {
512 String tableNameString = "testScanSizeSmall";
513 TableName tableName = TableName.valueOf(tableNameString);
514 byte[] cf = Bytes.toBytes("d");
515 byte[] qualifier = Bytes.toBytes("qual");
516 byte[] val = Bytes.toBytes("One");
517
518 List<Put> puts = new ArrayList<>();
519 for (int insertCount =0; insertCount < 100; insertCount++) {
520 Put p = new Put(Bytes.toBytes("" + insertCount + "row"));
521 p.add(cf, qualifier, val);
522 puts.add(p);
523 }
524 try (HTable t = TEST_UTIL.createTable(tableName, cf)) {
525 t.put(puts);
526
527 Scan s = new Scan();
528 s.setSmall(true);
529 s.setCaching(1);
530 ResultScanner resultScanners = t.getScanner(s);
531
532 for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) {
533 Result result = resultScanners.next();
534 assertNotNull(result);
535 assertEquals(1, result.size());
536 }
537 }
538 numScanNext += NUM_SCAN_NEXT;
539 try (RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName)) {
540 int cnt = 0;
541 for (HRegionLocation location: locator.getAllRegionLocations()) {
542 cnt++;
543 HRegionInfo i = location.getRegionInfo();
544 MetricsRegionAggregateSource agg = rs.getRegion(i.getRegionName())
545 .getMetrics()
546 .getSource()
547 .getAggregateSource();
548 String prefix = "namespace_"+NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR+
549 "_table_"+tableNameString +
550 "_region_" + i.getEncodedName()+
551 "_metric";
552 metricsHelper.assertCounter(prefix + "_scanCount", NUM_SCAN_NEXT, agg);
553 }
554 metricsHelper.assertCounterGt("ScanSize_num_ops", numScanNext, serverSource);
555 }
556 try (Admin admin = TEST_UTIL.getHBaseAdmin()) {
557 admin.disableTable(tableName);
558 admin.deleteTable(tableName);
559 }
560 }
561
562 @Test
563 @Ignore
564 public void testRangeCountMetrics() throws Exception {
565 String tableNameString = "testRangeCountMetrics";
566 final long[] timeranges =
567 { 1, 3, 10, 30, 100, 300, 1000, 3000, 10000, 30000, 60000, 120000, 300000, 600000 };
568 final String timeRangeType = "TimeRangeCount";
569 final String timeRangeMetricName = "Mutate";
570 boolean timeRangeCountUpdated = false;
571
572 TableName tName = TableName.valueOf(tableNameString);
573 byte[] cfName = Bytes.toBytes("d");
574 byte[] row = Bytes.toBytes("rk");
575 byte[] qualifier = Bytes.toBytes("qual");
576 byte[] initValue = Bytes.toBytes("Value");
577
578 TEST_UTIL.createTable(tName, cfName);
579
580 Connection connection = TEST_UTIL.getConnection();
581 connection.getTable(tName).close();
582
583
584 Table table = connection.getTable(tName);
585 Put p = new Put(row);
586 p.addColumn(cfName, qualifier, initValue);
587 table.put(p);
588
589
590 for (int i = 0; i < 10; i++) {
591 table.put(p);
592 }
593
594 Get g = new Get(row);
595 for (int i = 0; i < 10; i++) {
596 table.get(g);
597 }
598
599 metricsRegionServer.getRegionServerWrapper().forceRecompute();
600
601
602 long prior = 0;
603
604 String dynamicMetricName;
605 for (int i = 0; i < timeranges.length; i++) {
606 dynamicMetricName =
607 timeRangeMetricName + "_" + timeRangeType + "_" + prior + "-" + timeranges[i];
608 if (metricsHelper.checkCounterExists(dynamicMetricName, serverSource)) {
609 long count = metricsHelper.getGaugeLong(dynamicMetricName, serverSource);
610 if (count > 0) {
611 timeRangeCountUpdated = true;
612 break;
613 }
614 }
615 prior = timeranges[i];
616 }
617 dynamicMetricName =
618 timeRangeMetricName + "_" + timeRangeType + "_" + timeranges[timeranges.length - 1] + "-inf";
619 if (metricsHelper.checkCounterExists(dynamicMetricName, serverSource)) {
620 long count = metricsHelper.getCounter(dynamicMetricName, serverSource);
621 if (count > 0) {
622 timeRangeCountUpdated = true;
623 }
624 }
625 assertEquals(true, timeRangeCountUpdated);
626
627 table.close();
628 }
629
630 @Test
631 public void testAverageRegionSize() throws Exception {
632 TableName tableName = TableName.valueOf("testAverageRegionSize");
633 byte[] cf = Bytes.toBytes("d");
634 byte[] row = Bytes.toBytes("rk");
635 byte[] qualifier = Bytes.toBytes("qual");
636 byte[] val = Bytes.toBytes("Value");
637
638
639 Table t = TEST_UTIL.createTable(tableName, cf);
640 Put p = new Put(row);
641 p.addColumn(cf, qualifier, val);
642 t.put(p);
643 TEST_UTIL.getHBaseAdmin().flush(tableName);
644
645 metricsRegionServer.getRegionServerWrapper().forceRecompute();
646 assertTrue(metricsHelper.getGaugeDouble("averageRegionSize", serverSource) > 0.0);
647
648 t.close();
649 }
650 }