001/** 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018package org.apache.hadoop.hbase.regionserver; 019 020import static org.junit.Assert.assertEquals; 021import static org.junit.Assert.assertNotNull; 022import static org.junit.Assert.assertTrue; 023 024import java.io.IOException; 025import java.util.ArrayList; 026import java.util.List; 027import org.apache.hadoop.conf.Configuration; 028import org.apache.hadoop.hbase.CompatibilityFactory; 029import org.apache.hadoop.hbase.HBaseClassTestRule; 030import org.apache.hadoop.hbase.HBaseTestingUtility; 031import org.apache.hadoop.hbase.HColumnDescriptor; 032import org.apache.hadoop.hbase.HConstants; 033import org.apache.hadoop.hbase.HRegionInfo; 034import org.apache.hadoop.hbase.HRegionLocation; 035import org.apache.hadoop.hbase.HTableDescriptor; 036import org.apache.hadoop.hbase.MiniHBaseCluster; 037import org.apache.hadoop.hbase.NamespaceDescriptor; 038import org.apache.hadoop.hbase.TableName; 039import org.apache.hadoop.hbase.client.Admin; 040import org.apache.hadoop.hbase.client.Append; 041import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; 042import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; 043import org.apache.hadoop.hbase.client.Connection; 044import org.apache.hadoop.hbase.client.Durability; 045import org.apache.hadoop.hbase.client.Get; 046import org.apache.hadoop.hbase.client.Increment; 047import org.apache.hadoop.hbase.client.Put; 048import org.apache.hadoop.hbase.client.RegionLocator; 049import org.apache.hadoop.hbase.client.Result; 050import org.apache.hadoop.hbase.client.ResultScanner; 051import org.apache.hadoop.hbase.client.Scan; 052import org.apache.hadoop.hbase.client.Table; 053import org.apache.hadoop.hbase.client.TableDescriptor; 054import org.apache.hadoop.hbase.client.TableDescriptorBuilder; 055import org.apache.hadoop.hbase.master.LoadBalancer; 056import org.apache.hadoop.hbase.test.MetricsAssertHelper; 057import org.apache.hadoop.hbase.testclassification.LargeTests; 058import org.apache.hadoop.hbase.testclassification.RegionServerTests; 059import org.apache.hadoop.hbase.util.Bytes; 060import org.apache.hadoop.hbase.util.Threads; 061import org.junit.After; 062import org.junit.AfterClass; 063import org.junit.Before; 064import org.junit.BeforeClass; 065import org.junit.ClassRule; 066import org.junit.Ignore; 067import org.junit.Rule; 068import org.junit.Test; 069import org.junit.experimental.categories.Category; 070import org.junit.rules.TestName; 071import org.slf4j.Logger; 072import org.slf4j.LoggerFactory; 073 074@Category({RegionServerTests.class, LargeTests.class}) 075public class TestRegionServerMetrics { 076 077 @ClassRule 078 public static final HBaseClassTestRule CLASS_RULE = 079 HBaseClassTestRule.forClass(TestRegionServerMetrics.class); 080 081 private static final Logger LOG = LoggerFactory.getLogger(TestRegionServerMetrics.class); 082 083 @Rule 084 public TestName testName = new TestName(); 085 086 private static MetricsAssertHelper metricsHelper; 087 private static MiniHBaseCluster cluster; 088 private static HRegionServer rs; 089 private static Configuration conf; 090 private static HBaseTestingUtility TEST_UTIL; 091 private static Connection connection; 092 private static MetricsRegionServer metricsRegionServer; 093 private static MetricsRegionServerSource serverSource; 094 private static final int NUM_SCAN_NEXT = 30; 095 private static int numScanNext = 0; 096 private static byte[] cf = Bytes.toBytes("cf"); 097 private static byte[] row = Bytes.toBytes("row"); 098 private static byte[] qualifier = Bytes.toBytes("qual"); 099 private static byte[] val = Bytes.toBytes("val"); 100 private static Admin admin; 101 private static boolean TABLES_ON_MASTER; 102 103 @BeforeClass 104 public static void startCluster() throws Exception { 105 metricsHelper = CompatibilityFactory.getInstance(MetricsAssertHelper.class); 106 TEST_UTIL = new HBaseTestingUtility(); 107 TABLES_ON_MASTER = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration()); 108 conf = TEST_UTIL.getConfiguration(); 109 conf.getLong("hbase.splitlog.max.resubmit", 0); 110 // Make the failure test faster 111 conf.setInt("zookeeper.recovery.retry", 0); 112 // testMobMetrics creates few hfiles and manages compaction manually. 113 conf.setInt("hbase.hstore.compactionThreshold", 100); 114 conf.setInt("hbase.hstore.compaction.max", 100); 115 conf.setInt("hbase.regionserver.periodicmemstoreflusher.rangeofdelayseconds", 4*60); 116 conf.setInt(HConstants.REGIONSERVER_INFO_PORT, -1); 117 118 TEST_UTIL.startMiniCluster(); 119 cluster = TEST_UTIL.getHBaseCluster(); 120 cluster.waitForActiveAndReadyMaster(); 121 admin = TEST_UTIL.getAdmin(); 122 connection = TEST_UTIL.getConnection(); 123 124 while (cluster.getLiveRegionServerThreads().isEmpty() && 125 cluster.getRegionServer(0) == null && 126 rs.getRegionServerMetrics() == null) { 127 Threads.sleep(100); 128 } 129 rs = cluster.getRegionServer(0); 130 metricsRegionServer = rs.getRegionServerMetrics(); 131 serverSource = metricsRegionServer.getMetricsSource(); 132 } 133 134 @AfterClass 135 public static void after() throws Exception { 136 if (TEST_UTIL != null) { 137 TEST_UTIL.shutdownMiniCluster(); 138 } 139 } 140 141 TableName tableName; 142 Table table; 143 144 @Before 145 public void beforeTestMethod() throws Exception { 146 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 147 tableName = TableName.valueOf(testName.getMethodName()); 148 table = TEST_UTIL.createTable(tableName, cf); 149 } 150 151 @After 152 public void afterTestMethod() throws Exception { 153 admin.disableTable(tableName); 154 admin.deleteTable(tableName); 155 } 156 157 public void waitTableDeleted(TableName name, long timeoutInMillis) throws Exception { 158 long start = System.currentTimeMillis(); 159 while (true) { 160 HTableDescriptor[] tables = admin.listTables(); 161 for (HTableDescriptor htd : tables) { 162 if (htd.getNameAsString() == name.getNameAsString()) 163 return; 164 } 165 if (System.currentTimeMillis() - start > timeoutInMillis) 166 return; 167 Thread.sleep(1000); 168 } 169 } 170 171 public void assertCounter(String metric, long expectedValue) { 172 metricsHelper.assertCounter(metric, expectedValue, serverSource); 173 } 174 175 public void assertGauge(String metric, long expectedValue) { 176 metricsHelper.assertGauge(metric, expectedValue, serverSource); 177 } 178 179 // Aggregates metrics from regions and assert given list of metrics and expected values. 180 public void assertRegionMetrics(String metric, long expectedValue) throws Exception { 181 try (RegionLocator locator = connection.getRegionLocator(tableName)) { 182 for ( HRegionLocation location: locator.getAllRegionLocations()) { 183 HRegionInfo hri = location.getRegionInfo(); 184 MetricsRegionAggregateSource agg = 185 rs.getRegion(hri.getRegionName()).getMetrics().getSource().getAggregateSource(); 186 String prefix = "namespace_" + NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR + 187 "_table_" + tableName.getNameAsString() + 188 "_region_" + hri.getEncodedName()+ 189 "_metric_"; 190 metricsHelper.assertCounter(prefix + metric, expectedValue, agg); 191 } 192 } 193 } 194 195 public void doNPuts(int n, boolean batch) throws Exception { 196 if (batch) { 197 List<Put> puts = new ArrayList<>(); 198 for (int i = 0; i < n; i++) { 199 Put p = new Put(Bytes.toBytes("" + i + "row")).addColumn(cf, qualifier, val); 200 puts.add(p); 201 } 202 table.put(puts); 203 } else { 204 for (int i = 0; i < n; i++) { 205 Put p = new Put(row).addColumn(cf, qualifier, val); 206 table.put(p); 207 } 208 } 209 } 210 211 public void doNGets(int n, boolean batch) throws Exception { 212 if (batch) { 213 List<Get> gets = new ArrayList<>(); 214 for (int i = 0; i < n; i++) { 215 gets.add(new Get(row)); 216 } 217 table.get(gets); 218 } else { 219 for (int i = 0; i < n; i++) { 220 table.get(new Get(row)); 221 } 222 } 223 } 224 225 public void doScan(int n, boolean caching) throws IOException { 226 Scan scan = new Scan(); 227 if (caching) { 228 scan.setCaching(n); 229 } else { 230 scan.setCaching(1); 231 } 232 ResultScanner scanner = table.getScanner(scan); 233 for (int i = 0; i < n; i++) { 234 Result res = scanner.next(); 235 LOG.debug("Result row: " + Bytes.toString(res.getRow()) + ", value: " + 236 Bytes.toString(res.getValue(cf, qualifier))); 237 } 238 } 239 240 @Test 241 public void testRegionCount() throws Exception { 242 metricsHelper.assertGauge("regionCount", TABLES_ON_MASTER? 1: 3, serverSource); 243 } 244 245 @Test 246 public void testLocalFiles() throws Exception { 247 assertGauge("percentFilesLocal", 0); 248 assertGauge("percentFilesLocalSecondaryRegions", 0); 249 } 250 251 @Test 252 public void testRequestCount() throws Exception { 253 // Do a first put to be sure that the connection is established, meta is there and so on. 254 doNPuts(1, false); 255 256 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 257 long requests = metricsHelper.getCounter("totalRequestCount", serverSource); 258 long rowActionRequests = metricsHelper.getCounter("totalRowActionRequestCount", serverSource); 259 long readRequests = metricsHelper.getCounter("readRequestCount", serverSource); 260 long writeRequests = metricsHelper.getCounter("writeRequestCount", serverSource); 261 262 doNPuts(30, false); 263 264 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 265 assertCounter("totalRequestCount", requests + 30); 266 assertCounter("totalRowActionRequestCount", rowActionRequests + 30); 267 assertCounter("readRequestCount", readRequests); 268 assertCounter("writeRequestCount", writeRequests + 30); 269 270 doNGets(10, false); 271 272 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 273 assertCounter("totalRequestCount", requests + 40); 274 assertCounter("totalRowActionRequestCount", rowActionRequests + 40); 275 assertCounter("readRequestCount", readRequests + 10); 276 assertCounter("writeRequestCount", writeRequests + 30); 277 278 assertRegionMetrics("getCount", 10); 279 assertRegionMetrics("putCount", 31); 280 281 doNGets(10, true); // true = batch 282 283 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 284 if (TABLES_ON_MASTER) { 285 assertCounter("totalRequestCount", requests + 41); 286 assertCounter("totalRowActionRequestCount", rowActionRequests + 50); 287 assertCounter("readRequestCount", readRequests + 20); 288 } 289 290 291 assertCounter("writeRequestCount", writeRequests + 30); 292 293 doNPuts(30, true); 294 295 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 296 if (TABLES_ON_MASTER) { 297 assertCounter("totalRequestCount", requests + 42); 298 assertCounter("totalRowActionRequestCount", rowActionRequests + 80); 299 assertCounter("readRequestCount", readRequests + 20); 300 } 301 assertCounter("writeRequestCount", writeRequests + 60); 302 303 doScan(10, false); // test after batch put so we have enough lines 304 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 305 if (TABLES_ON_MASTER) { 306 assertCounter("totalRequestCount", requests + 52); 307 assertCounter("totalRowActionRequestCount", rowActionRequests + 90); 308 assertCounter("readRequestCount", readRequests + 30); 309 } 310 assertCounter("writeRequestCount", writeRequests + 60); 311 numScanNext += 10; 312 313 doScan(10, true); // true = caching 314 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 315 if (TABLES_ON_MASTER) { 316 assertCounter("totalRequestCount", requests + 53); 317 assertCounter("totalRowActionRequestCount", rowActionRequests + 100); 318 assertCounter("readRequestCount", readRequests + 40); 319 } 320 assertCounter("writeRequestCount", writeRequests + 60); 321 numScanNext += 1; 322 } 323 324 @Test 325 public void testGet() throws Exception { 326 // Do a first put to be sure that the connection is established, meta is there and so on. 327 doNPuts(1, false); 328 doNGets(10, false); 329 assertRegionMetrics("getCount", 10); 330 metricsHelper.assertCounterGt("Get_num_ops", 10, serverSource); 331 } 332 333 @Test 334 public void testMutationsWithoutWal() throws Exception { 335 Put p = new Put(row).addColumn(cf, qualifier, val) 336 .setDurability(Durability.SKIP_WAL); 337 table.put(p); 338 339 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 340 assertGauge("mutationsWithoutWALCount", 1); 341 long minLength = row.length + cf.length + qualifier.length + val.length; 342 metricsHelper.assertGaugeGt("mutationsWithoutWALSize", minLength, serverSource); 343 } 344 345 @Test 346 public void testStoreCount() throws Exception { 347 // Force a hfile. 348 doNPuts(1, false); 349 TEST_UTIL.getAdmin().flush(tableName); 350 351 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 352 assertGauge("storeCount", TABLES_ON_MASTER ? 1 : 5); 353 assertGauge("storeFileCount", 1); 354 } 355 356 @Test 357 public void testStoreFileAge() throws Exception { 358 //Force a hfile. 359 doNPuts(1, false); 360 TEST_UTIL.getAdmin().flush(tableName); 361 362 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 363 assertTrue(metricsHelper.getGaugeLong("maxStoreFileAge", serverSource) > 0); 364 assertTrue(metricsHelper.getGaugeLong("minStoreFileAge", serverSource) > 0); 365 assertTrue(metricsHelper.getGaugeLong("avgStoreFileAge", serverSource) > 0); 366 } 367 368 @Test 369 public void testCheckAndPutCount() throws Exception { 370 byte[] valOne = Bytes.toBytes("Value"); 371 byte[] valTwo = Bytes.toBytes("ValueTwo"); 372 byte[] valThree = Bytes.toBytes("ValueThree"); 373 374 Put p = new Put(row); 375 p.addColumn(cf, qualifier, valOne); 376 table.put(p); 377 378 Put pTwo = new Put(row); 379 pTwo.addColumn(cf, qualifier, valTwo); 380 table.checkAndMutate(row, cf).qualifier(qualifier).ifEquals(valOne).thenPut(pTwo); 381 382 Put pThree = new Put(row); 383 pThree.addColumn(cf, qualifier, valThree); 384 table.checkAndMutate(row, cf).qualifier(qualifier).ifEquals(valOne).thenPut(pThree); 385 386 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 387 assertCounter("checkMutateFailedCount", 1); 388 assertCounter("checkMutatePassedCount", 1); 389 } 390 391 @Test 392 public void testIncrement() throws Exception { 393 Put p = new Put(row).addColumn(cf, qualifier, Bytes.toBytes(0L)); 394 table.put(p); 395 396 for(int count = 0; count < 13; count++) { 397 Increment inc = new Increment(row); 398 inc.addColumn(cf, qualifier, 100); 399 table.increment(inc); 400 } 401 402 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 403 assertCounter("incrementNumOps", 13); 404 } 405 406 @Test 407 public void testAppend() throws Exception { 408 doNPuts(1, false); 409 410 for(int count = 0; count< 73; count++) { 411 Append append = new Append(row); 412 append.addColumn(cf, qualifier, Bytes.toBytes(",Test")); 413 table.append(append); 414 } 415 416 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 417 assertCounter("appendNumOps", 73); 418 } 419 420 @Test 421 public void testScanSize() throws Exception { 422 doNPuts(100, true); // batch put 423 Scan s = new Scan(); 424 s.setBatch(1); 425 s.setCaching(1); 426 ResultScanner resultScanners = table.getScanner(s); 427 428 for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) { 429 Result result = resultScanners.next(); 430 assertNotNull(result); 431 assertEquals(1, result.size()); 432 } 433 numScanNext += NUM_SCAN_NEXT; 434 assertRegionMetrics("scanCount", NUM_SCAN_NEXT); 435 if (TABLES_ON_MASTER) { 436 assertCounter("ScanSize_num_ops", numScanNext); 437 } 438 } 439 440 @Test 441 public void testScanTime() throws Exception { 442 doNPuts(100, true); 443 Scan s = new Scan(); 444 s.setBatch(1); 445 s.setCaching(1); 446 ResultScanner resultScanners = table.getScanner(s); 447 448 for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) { 449 Result result = resultScanners.next(); 450 assertNotNull(result); 451 assertEquals(1, result.size()); 452 } 453 numScanNext += NUM_SCAN_NEXT; 454 assertRegionMetrics("scanCount", NUM_SCAN_NEXT); 455 if (TABLES_ON_MASTER) { 456 assertCounter("ScanTime_num_ops", numScanNext); 457 } 458 } 459 460 @Test 461 public void testScanSizeForSmallScan() throws Exception { 462 doNPuts(100, true); 463 Scan s = new Scan(); 464 s.setSmall(true); 465 s.setCaching(1); 466 ResultScanner resultScanners = table.getScanner(s); 467 468 for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) { 469 Result result = resultScanners.next(); 470 assertNotNull(result); 471 if (TABLES_ON_MASTER) { 472 assertEquals(1, result.size()); 473 } 474 } 475 numScanNext += NUM_SCAN_NEXT; 476 assertRegionMetrics("scanCount", NUM_SCAN_NEXT); 477 if (TABLES_ON_MASTER) { 478 assertCounter("ScanSize_num_ops", numScanNext); 479 } 480 } 481 482 @Test 483 public void testMobMetrics() throws IOException, InterruptedException { 484 TableName tableName = TableName.valueOf("testMobMetricsLocal"); 485 int numHfiles = 5; 486 HTableDescriptor htd = new HTableDescriptor(tableName); 487 HColumnDescriptor hcd = new HColumnDescriptor(cf); 488 hcd.setMobEnabled(true); 489 hcd.setMobThreshold(0); 490 htd.addFamily(hcd); 491 byte[] val = Bytes.toBytes("mobdata"); 492 try { 493 Table table = TEST_UTIL.createTable(htd, new byte[0][0], conf); 494 HRegion region = rs.getRegions(tableName).get(0); 495 for (int insertCount = 0; insertCount < numHfiles; insertCount++) { 496 Put p = new Put(Bytes.toBytes(insertCount)); 497 p.addColumn(cf, qualifier, val); 498 table.put(p); 499 admin.flush(tableName); 500 } 501 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 502 assertCounter("mobFlushCount", numHfiles); 503 Scan scan = new Scan(Bytes.toBytes(0), Bytes.toBytes(numHfiles)); 504 ResultScanner scanner = table.getScanner(scan); 505 scanner.next(100); 506 numScanNext++; // this is an ugly construct 507 scanner.close(); 508 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 509 assertCounter("mobScanCellsCount", numHfiles); 510 511 setMobThreshold(region, cf, 100); 512 // metrics are reset by the region initialization 513 region.initialize(); 514 region.compact(true); 515 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 516 assertCounter("cellsCountCompactedFromMob", numHfiles); 517 assertCounter("cellsCountCompactedToMob", 0); 518 519 scanner = table.getScanner(scan); 520 scanner.next(100); 521 numScanNext++; // this is an ugly construct 522 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 523 assertCounter("mobScanCellsCount", 0); 524 525 for (int insertCount = numHfiles; insertCount < 2 * numHfiles; insertCount++) { 526 Put p = new Put(Bytes.toBytes(insertCount)); 527 p.addColumn(cf, qualifier, val); 528 table.put(p); 529 admin.flush(tableName); 530 } 531 setMobThreshold(region, cf, 0); 532 533 // closing the region forces the compaction.discharger to archive the compacted hfiles 534 region.close(); 535 536 // metrics are reset by the region initialization 537 region.initialize(); 538 region.compact(true); 539 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 540 // metrics are reset by the region initialization 541 assertCounter("cellsCountCompactedFromMob", 0); 542 assertCounter("cellsCountCompactedToMob", 2 * numHfiles); 543 } finally { 544 admin.disableTable(tableName); 545 admin.deleteTable(tableName); 546 } 547 } 548 549 private static Region setMobThreshold(Region region, byte[] cfName, long modThreshold) { 550 ColumnFamilyDescriptor cfd = ColumnFamilyDescriptorBuilder 551 .newBuilder(region.getTableDescriptor().getColumnFamily(cfName)) 552 .setMobThreshold(modThreshold) 553 .build(); 554 TableDescriptor td = TableDescriptorBuilder 555 .newBuilder(region.getTableDescriptor()) 556 .removeColumnFamily(cfName) 557 .setColumnFamily(cfd) 558 .build(); 559 ((HRegion)region).setTableDescriptor(td); 560 return region; 561 } 562 563 @Test 564 @Ignore 565 public void testRangeCountMetrics() throws Exception { 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 // Do a first put to be sure that the connection is established, meta is there and so on. 573 Put p = new Put(row); 574 p.addColumn(cf, qualifier, val); 575 table.put(p); 576 577 // do some puts and gets 578 for (int i = 0; i < 10; i++) { 579 table.put(p); 580 } 581 582 Get g = new Get(row); 583 for (int i = 0; i < 10; i++) { 584 table.get(g); 585 } 586 587 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 588 589 // Check some time range counters were updated 590 long prior = 0; 591 592 String dynamicMetricName; 593 for (int i = 0; i < timeranges.length; i++) { 594 dynamicMetricName = 595 timeRangeMetricName + "_" + timeRangeType + "_" + prior + "-" + timeranges[i]; 596 if (metricsHelper.checkCounterExists(dynamicMetricName, serverSource)) { 597 long count = metricsHelper.getGaugeLong(dynamicMetricName, serverSource); 598 if (count > 0) { 599 timeRangeCountUpdated = true; 600 break; 601 } 602 } 603 prior = timeranges[i]; 604 } 605 dynamicMetricName = 606 timeRangeMetricName + "_" + timeRangeType + "_" + timeranges[timeranges.length - 1] + "-inf"; 607 if (metricsHelper.checkCounterExists(dynamicMetricName, serverSource)) { 608 long count = metricsHelper.getCounter(dynamicMetricName, serverSource); 609 if (count > 0) { 610 timeRangeCountUpdated = true; 611 } 612 } 613 assertEquals(true, timeRangeCountUpdated); 614 } 615 616 @Test 617 public void testAverageRegionSize() throws Exception { 618 //Force a hfile. 619 doNPuts(1, false); 620 TEST_UTIL.getAdmin().flush(tableName); 621 622 metricsRegionServer.getRegionServerWrapper().forceRecompute(); 623 assertTrue(metricsHelper.getGaugeDouble("averageRegionSize", serverSource) > 0.0); 624 } 625}