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.assertFalse; 021import static org.junit.Assert.assertNotNull; 022import static org.junit.Assert.assertTrue; 023import static org.mockito.Mockito.mock; 024import static org.mockito.Mockito.when; 025 026import org.apache.hadoop.conf.Configuration; 027import org.apache.hadoop.hbase.CompatibilityFactory; 028import org.apache.hadoop.hbase.HBaseClassTestRule; 029import org.apache.hadoop.hbase.metrics.MetricRegistries; 030import org.apache.hadoop.hbase.quotas.RpcThrottlingException; 031import org.apache.hadoop.hbase.regionserver.metrics.MetricsTableRequests; 032import org.apache.hadoop.hbase.test.MetricsAssertHelper; 033import org.apache.hadoop.hbase.testclassification.RegionServerTests; 034import org.apache.hadoop.hbase.testclassification.SmallTests; 035import org.apache.hadoop.hbase.util.JvmPauseMonitor; 036import org.junit.After; 037import org.junit.Before; 038import org.junit.BeforeClass; 039import org.junit.ClassRule; 040import org.junit.Test; 041import org.junit.experimental.categories.Category; 042 043/** 044 * Unit test version of rs metrics tests. 045 */ 046@Category({ RegionServerTests.class, SmallTests.class }) 047public class TestMetricsRegionServer { 048 049 @ClassRule 050 public static final HBaseClassTestRule CLASS_RULE = 051 HBaseClassTestRule.forClass(TestMetricsRegionServer.class); 052 053 public static MetricsAssertHelper HELPER = 054 CompatibilityFactory.getInstance(MetricsAssertHelper.class); 055 056 private MetricsRegionServerWrapperStub wrapper; 057 private MetricsRegionServer rsm; 058 private MetricsRegionServerSource serverSource; 059 060 @BeforeClass 061 public static void classSetUp() { 062 HELPER.init(); 063 } 064 065 @Before 066 public void setUp() { 067 wrapper = new MetricsRegionServerWrapperStub(); 068 rsm = new MetricsRegionServer(wrapper, new Configuration(false), null); 069 serverSource = rsm.getMetricsSource(); 070 } 071 072 @After 073 public void tearDown() { 074 // Clean up global registries after each test to avoid interference 075 MetricRegistries.global().clear(); 076 } 077 078 @Test 079 public void testWrapperSource() { 080 HELPER.assertTag("serverName", "test", serverSource); 081 HELPER.assertTag("clusterId", "tClusterId", serverSource); 082 HELPER.assertTag("zookeeperQuorum", "zk", serverSource); 083 HELPER.assertGauge("regionServerStartTime", 100, serverSource); 084 HELPER.assertGauge("regionCount", 101, serverSource); 085 HELPER.assertGauge("storeCount", 2, serverSource); 086 HELPER.assertGauge("maxStoreFileCount", 23, serverSource); 087 HELPER.assertGauge("maxStoreFileAge", 2, serverSource); 088 HELPER.assertGauge("minStoreFileAge", 2, serverSource); 089 HELPER.assertGauge("avgStoreFileAge", 2, serverSource); 090 HELPER.assertGauge("numReferenceFiles", 2, serverSource); 091 HELPER.assertGauge("hlogFileCount", 10, serverSource); 092 HELPER.assertGauge("hlogFileSize", 1024000, serverSource); 093 HELPER.assertGauge("storeFileCount", 300, serverSource); 094 HELPER.assertGauge("memstoreSize", 1025, serverSource); 095 HELPER.assertGauge("memstoreHeapSize", 500, serverSource); 096 HELPER.assertGauge("memstoreOffHeapSize", 600, serverSource); 097 HELPER.assertGauge("storeFileSize", 1900, serverSource); 098 HELPER.assertGauge("storeFileSizeGrowthRate", 50.0, serverSource); 099 HELPER.assertCounter("totalRequestCount", 899, serverSource); 100 HELPER.assertCounter("totalRowActionRequestCount", 101 HELPER.getCounter("readRequestCount", serverSource) 102 + HELPER.getCounter("writeRequestCount", serverSource), 103 serverSource); 104 HELPER.assertCounter("readRequestCount", 997, serverSource); 105 HELPER.assertCounter("cpRequestCount", 998, serverSource); 106 HELPER.assertCounter("filteredReadRequestCount", 1997, serverSource); 107 HELPER.assertCounter("writeRequestCount", 707, serverSource); 108 HELPER.assertCounter("checkMutateFailedCount", 401, serverSource); 109 HELPER.assertCounter("checkMutatePassedCount", 405, serverSource); 110 HELPER.assertGauge("storeFileIndexSize", 406, serverSource); 111 HELPER.assertGauge("staticIndexSize", 407, serverSource); 112 HELPER.assertGauge("staticBloomSize", 408, serverSource); 113 HELPER.assertGauge("mutationsWithoutWALCount", 409, serverSource); 114 HELPER.assertGauge("mutationsWithoutWALSize", 410, serverSource); 115 HELPER.assertCounter("bloomFilterRequestsCount", 411, serverSource); 116 HELPER.assertCounter("bloomFilterNegativeResultsCount", 412, serverSource); 117 HELPER.assertCounter("bloomFilterEligibleRequestsCount", 413, serverSource); 118 HELPER.assertGauge("percentFilesLocal", 99, serverSource); 119 HELPER.assertGauge("percentFilesLocalSecondaryRegions", 99, serverSource); 120 HELPER.assertGauge("compactionQueueLength", 411, serverSource); 121 HELPER.assertGauge("flushQueueLength", 412, serverSource); 122 HELPER.assertGauge("blockCacheFreeSize", 413, serverSource); 123 HELPER.assertGauge("blockCacheCount", 414, serverSource); 124 HELPER.assertGauge("blockCacheDataBlockCount", 300, serverSource); 125 HELPER.assertGauge("blockCacheSize", 415, serverSource); 126 HELPER.assertCounter("blockCacheHitCount", 416, serverSource); 127 HELPER.assertCounter("blockCacheHitCachingCount", 16, serverSource); 128 HELPER.assertCounter("blockCacheMissCount", 417, serverSource); 129 HELPER.assertCounter("blockCacheMissCachingCount", 17, serverSource); 130 HELPER.assertCounter("blockCacheEvictionCount", 418, serverSource); 131 HELPER.assertGauge("blockCacheCountHitPercent", 98, serverSource); 132 HELPER.assertGauge("blockCacheExpressHitPercent", 97, serverSource); 133 HELPER.assertCounter("blockCacheFailedInsertionCount", 36, serverSource); 134 HELPER.assertGauge("l1CacheFreeSize", 100, serverSource); 135 HELPER.assertGauge("l1CacheSize", 123, serverSource); 136 HELPER.assertGauge("l1CacheCount", 50, serverSource); 137 HELPER.assertCounter("l1CacheEvictionCount", 1000, serverSource); 138 HELPER.assertGauge("l1CacheHitCount", 200, serverSource); 139 HELPER.assertGauge("l1CacheMissCount", 100, serverSource); 140 HELPER.assertGauge("l1CacheHitRatio", 80, serverSource); 141 HELPER.assertGauge("l1CacheMissRatio", 20, serverSource); 142 HELPER.assertGauge("l2CacheFreeSize", 200, serverSource); 143 HELPER.assertGauge("l2CacheSize", 456, serverSource); 144 HELPER.assertGauge("l2CacheCount", 75, serverSource); 145 HELPER.assertCounter("l2CacheEvictionCount", 2000, serverSource); 146 HELPER.assertGauge("l2CacheHitCount", 800, serverSource); 147 HELPER.assertGauge("l2CacheMissCount", 200, serverSource); 148 HELPER.assertGauge("l2CacheHitRatio", 90, serverSource); 149 HELPER.assertGauge("l2CacheMissRatio", 10, serverSource); 150 HELPER.assertCounter("updatesBlockedTime", 419, serverSource); 151 } 152 153 @Test 154 public void testConstuctor() { 155 assertNotNull("There should be a hadoop1/hadoop2 metrics source", rsm.getMetricsSource()); 156 assertNotNull("The RegionServerMetricsWrapper should be accessable", 157 rsm.getRegionServerWrapper()); 158 } 159 160 @Test 161 public void testSlowCount() { 162 HRegion region = mock(HRegion.class); 163 MetricsTableRequests metricsTableRequests = mock(MetricsTableRequests.class); 164 when(region.getMetricsTableRequests()).thenReturn(metricsTableRequests); 165 when(metricsTableRequests.isEnableTableLatenciesMetrics()).thenReturn(false); 166 when(metricsTableRequests.isEnabTableQueryMeterMetrics()).thenReturn(false); 167 for (int i = 0; i < 12; i++) { 168 rsm.updateAppend(region, 12, 120); 169 rsm.updateAppend(region, 1002, 10020); 170 } 171 for (int i = 0; i < 13; i++) { 172 rsm.updateDeleteBatch(region, 13); 173 rsm.updateDeleteBatch(region, 1003); 174 } 175 for (int i = 0; i < 14; i++) { 176 rsm.updateGet(region, 14, 140); 177 rsm.updateGet(region, 1004, 10040); 178 } 179 for (int i = 0; i < 15; i++) { 180 rsm.updateIncrement(region, 15, 150); 181 rsm.updateIncrement(region, 1005, 10050); 182 } 183 for (int i = 0; i < 16; i++) { 184 rsm.updatePutBatch(region, 16); 185 rsm.updatePutBatch(region, 1006); 186 } 187 188 for (int i = 0; i < 17; i++) { 189 rsm.updatePut(region, 17); 190 rsm.updateDelete(region, 17); 191 rsm.updatePut(region, 1006); 192 rsm.updateDelete(region, 1003); 193 rsm.updateCheckAndDelete(region, 17); 194 rsm.updateCheckAndPut(region, 17); 195 rsm.updateCheckAndMutate(region, 17, 170); 196 } 197 198 HELPER.assertCounter("blockBytesScannedCount", 420090, serverSource); 199 HELPER.assertCounter("appendNumOps", 24, serverSource); 200 HELPER.assertCounter("appendBlockBytesScannedNumOps", 24, serverSource); 201 HELPER.assertCounter("deleteBatchNumOps", 26, serverSource); 202 HELPER.assertCounter("getNumOps", 28, serverSource); 203 HELPER.assertCounter("getBlockBytesScannedNumOps", 28, serverSource); 204 HELPER.assertCounter("incrementNumOps", 30, serverSource); 205 HELPER.assertCounter("incrementBlockBytesScannedNumOps", 30, serverSource); 206 HELPER.assertCounter("putBatchNumOps", 32, serverSource); 207 HELPER.assertCounter("putNumOps", 34, serverSource); 208 HELPER.assertCounter("deleteNumOps", 34, serverSource); 209 HELPER.assertCounter("checkAndDeleteNumOps", 17, serverSource); 210 HELPER.assertCounter("checkAndPutNumOps", 17, serverSource); 211 HELPER.assertCounter("checkAndMutateNumOps", 17, serverSource); 212 HELPER.assertCounter("checkAndMutateBlockBytesScannedNumOps", 17, serverSource); 213 214 HELPER.assertCounter("slowAppendCount", 12, serverSource); 215 HELPER.assertCounter("slowDeleteCount", 17, serverSource); 216 HELPER.assertCounter("slowGetCount", 14, serverSource); 217 HELPER.assertCounter("slowIncrementCount", 15, serverSource); 218 HELPER.assertCounter("slowPutCount", 17, serverSource); 219 } 220 221 @Test 222 public void testFlush() { 223 rsm.updateFlush(null, 1, 2, 3); 224 HELPER.assertCounter("flushTime_num_ops", 1, serverSource); 225 HELPER.assertCounter("flushMemstoreSize_num_ops", 1, serverSource); 226 HELPER.assertCounter("flushOutputSize_num_ops", 1, serverSource); 227 HELPER.assertCounter("flushedMemstoreBytes", 2, serverSource); 228 HELPER.assertCounter("flushedOutputBytes", 3, serverSource); 229 230 rsm.updateFlush(null, 10, 20, 30); 231 HELPER.assertCounter("flushTimeNumOps", 2, serverSource); 232 HELPER.assertCounter("flushMemstoreSize_num_ops", 2, serverSource); 233 HELPER.assertCounter("flushOutputSize_num_ops", 2, serverSource); 234 HELPER.assertCounter("flushedMemstoreBytes", 22, serverSource); 235 HELPER.assertCounter("flushedOutputBytes", 33, serverSource); 236 } 237 238 @Test 239 public void testCompaction() { 240 rsm.updateCompaction(null, false, 1, 2, 3, 4, 5); 241 HELPER.assertCounter("compactionTime_num_ops", 1, serverSource); 242 HELPER.assertCounter("compactionInputFileCount_num_ops", 1, serverSource); 243 HELPER.assertCounter("compactionInputSize_num_ops", 1, serverSource); 244 HELPER.assertCounter("compactionOutputFileCount_num_ops", 1, serverSource); 245 HELPER.assertCounter("compactedInputBytes", 4, serverSource); 246 HELPER.assertCounter("compactedoutputBytes", 5, serverSource); 247 248 rsm.updateCompaction(null, false, 10, 20, 30, 40, 50); 249 HELPER.assertCounter("compactionTime_num_ops", 2, serverSource); 250 HELPER.assertCounter("compactionInputFileCount_num_ops", 2, serverSource); 251 HELPER.assertCounter("compactionInputSize_num_ops", 2, serverSource); 252 HELPER.assertCounter("compactionOutputFileCount_num_ops", 2, serverSource); 253 HELPER.assertCounter("compactedInputBytes", 44, serverSource); 254 HELPER.assertCounter("compactedoutputBytes", 55, serverSource); 255 256 // do major compaction 257 rsm.updateCompaction(null, true, 100, 200, 300, 400, 500); 258 259 HELPER.assertCounter("compactionTime_num_ops", 3, serverSource); 260 HELPER.assertCounter("compactionInputFileCount_num_ops", 3, serverSource); 261 HELPER.assertCounter("compactionInputSize_num_ops", 3, serverSource); 262 HELPER.assertCounter("compactionOutputFileCount_num_ops", 3, serverSource); 263 HELPER.assertCounter("compactedInputBytes", 444, serverSource); 264 HELPER.assertCounter("compactedoutputBytes", 555, serverSource); 265 266 HELPER.assertCounter("majorCompactionTime_num_ops", 1, serverSource); 267 HELPER.assertCounter("majorCompactionInputFileCount_num_ops", 1, serverSource); 268 HELPER.assertCounter("majorCompactionInputSize_num_ops", 1, serverSource); 269 HELPER.assertCounter("majorCompactionOutputFileCount_num_ops", 1, serverSource); 270 HELPER.assertCounter("majorCompactedInputBytes", 400, serverSource); 271 HELPER.assertCounter("majorCompactedoutputBytes", 500, serverSource); 272 } 273 274 @Test 275 public void testPauseMonitor() { 276 Configuration conf = new Configuration(); 277 conf.setLong(JvmPauseMonitor.INFO_THRESHOLD_KEY, 1000L); 278 conf.setLong(JvmPauseMonitor.WARN_THRESHOLD_KEY, 10000L); 279 JvmPauseMonitor monitor = new JvmPauseMonitor(conf, serverSource); 280 monitor.updateMetrics(1500, false); 281 HELPER.assertCounter("pauseInfoThresholdExceeded", 1, serverSource); 282 HELPER.assertCounter("pauseWarnThresholdExceeded", 0, serverSource); 283 HELPER.assertCounter("pauseTimeWithoutGc_num_ops", 1, serverSource); 284 HELPER.assertCounter("pauseTimeWithGc_num_ops", 0, serverSource); 285 monitor.updateMetrics(15000, true); 286 HELPER.assertCounter("pauseInfoThresholdExceeded", 1, serverSource); 287 HELPER.assertCounter("pauseWarnThresholdExceeded", 1, serverSource); 288 HELPER.assertCounter("pauseTimeWithoutGc_num_ops", 1, serverSource); 289 HELPER.assertCounter("pauseTimeWithGc_num_ops", 1, serverSource); 290 } 291 292 @Test 293 public void testScannerMetrics() { 294 HELPER.assertCounter("scannerLeaseExpiredCount", 0, serverSource); 295 rsm.incrScannerLeaseExpired(); 296 HELPER.assertCounter("scannerLeaseExpiredCount", 1, serverSource); 297 HELPER.assertGauge("activeScanners", 0, serverSource); 298 } 299 300 @Test 301 public void testTableQueryMeterSwitch() { 302 HRegion region = mock(HRegion.class); 303 MetricsTableRequests metricsTableRequests = mock(MetricsTableRequests.class); 304 when(region.getMetricsTableRequests()).thenReturn(metricsTableRequests); 305 when(metricsTableRequests.isEnableTableLatenciesMetrics()).thenReturn(false); 306 when(metricsTableRequests.isEnabTableQueryMeterMetrics()).thenReturn(false); 307 Configuration conf = new Configuration(false); 308 // disable 309 rsm.updateReadQueryMeter(region, 500L); 310 assertFalse(HELPER.checkGaugeExists("ServerReadQueryPerSecond_count", serverSource)); 311 rsm.updateWriteQueryMeter(region, 500L); 312 assertFalse(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); 313 314 // enable 315 conf.setBoolean(MetricsRegionServer.RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY, true); 316 rsm = new MetricsRegionServer(wrapper, conf, null); 317 serverSource = rsm.getMetricsSource(); 318 rsm.updateReadQueryMeter(region, 500L); 319 assertTrue(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); 320 HELPER.assertGauge("ServerReadQueryPerSecond_count", 500L, serverSource); 321 assertTrue(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); 322 rsm.updateWriteQueryMeter(region, 500L); 323 HELPER.assertGauge("ServerWriteQueryPerSecond_count", 500L, serverSource); 324 } 325 326 @Test 327 public void testThrottleExceptionMetricsIntegration() { 328 // Record different types of throttle exceptions 329 rsm.recordThrottleException(RpcThrottlingException.Type.NumRequestsExceeded, "alice", "users"); 330 rsm.recordThrottleException(RpcThrottlingException.Type.WriteSizeExceeded, "bob", "logs"); 331 rsm.recordThrottleException(RpcThrottlingException.Type.ReadSizeExceeded, "charlie", 332 "metadata"); 333 334 // Record the same exception multiple times to test increment 335 rsm.recordThrottleException(RpcThrottlingException.Type.NumRequestsExceeded, "alice", "users"); 336 rsm.recordThrottleException(RpcThrottlingException.Type.NumRequestsExceeded, "alice", "users"); 337 338 // Verify the specific counters were created and have correct values using HELPER 339 HELPER.assertCounter("RpcThrottlingException_Type_NumRequestsExceeded_User_alice_Table_users", 340 3L, serverSource); 341 HELPER.assertCounter("RpcThrottlingException_Type_WriteSizeExceeded_User_bob_Table_logs", 1L, 342 serverSource); 343 HELPER.assertCounter("RpcThrottlingException_Type_ReadSizeExceeded_User_charlie_Table_metadata", 344 1L, serverSource); 345 346 // Test metric name sanitization through the integration 347 rsm.recordThrottleException(RpcThrottlingException.Type.RequestSizeExceeded, 348 "user.with@special", "table:with,problematic=chars"); 349 HELPER.assertCounter( 350 "RpcThrottlingException_Type_RequestSizeExceeded_User_user.with@special_Table_table_with_problematic_chars", 351 1L, serverSource); 352 353 // Test null handling through the integration 354 rsm.recordThrottleException(RpcThrottlingException.Type.ReadCapacityUnitExceeded, null, null); 355 HELPER.assertCounter( 356 "RpcThrottlingException_Type_ReadCapacityUnitExceeded_User_unknown_Table_unknown", 1L, 357 serverSource); 358 } 359}