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("l1CacheHitCachingCount", 200, serverSource); 140 HELPER.assertGauge("l1CacheMissCount", 100, serverSource); 141 HELPER.assertGauge("l1CacheMissCachingCount", 100, serverSource); 142 HELPER.assertGauge("l1CacheHitRatio", 80, serverSource); 143 HELPER.assertGauge("l1CacheHitCachingRatio", 80, serverSource); 144 HELPER.assertGauge("l1CacheMissRatio", 20, serverSource); 145 HELPER.assertGauge("l1CacheMissCachingRatio", 20, serverSource); 146 HELPER.assertGauge("l2CacheFreeSize", 200, serverSource); 147 HELPER.assertGauge("l2CacheSize", 456, serverSource); 148 HELPER.assertGauge("l2CacheCount", 75, serverSource); 149 HELPER.assertCounter("l2CacheEvictionCount", 2000, serverSource); 150 HELPER.assertGauge("l2CacheHitCount", 800, serverSource); 151 HELPER.assertGauge("l2CacheHitCachingCount", 800, serverSource); 152 HELPER.assertGauge("l2CacheMissCount", 200, serverSource); 153 HELPER.assertGauge("l2CacheMissCachingCount", 200, serverSource); 154 HELPER.assertGauge("l2CacheHitRatio", 90, serverSource); 155 HELPER.assertGauge("l2CacheHitCachingRatio", 90, serverSource); 156 HELPER.assertGauge("l2CacheMissRatio", 10, serverSource); 157 HELPER.assertGauge("l2CacheMissCachingRatio", 10, serverSource); 158 HELPER.assertCounter("updatesBlockedTime", 419, serverSource); 159 } 160 161 @Test 162 public void testConstuctor() { 163 assertNotNull("There should be a hadoop1/hadoop2 metrics source", rsm.getMetricsSource()); 164 assertNotNull("The RegionServerMetricsWrapper should be accessable", 165 rsm.getRegionServerWrapper()); 166 } 167 168 @Test 169 public void testSlowCount() { 170 HRegion region = mock(HRegion.class); 171 MetricsTableRequests metricsTableRequests = mock(MetricsTableRequests.class); 172 when(region.getMetricsTableRequests()).thenReturn(metricsTableRequests); 173 when(metricsTableRequests.isEnableTableLatenciesMetrics()).thenReturn(false); 174 when(metricsTableRequests.isEnabTableQueryMeterMetrics()).thenReturn(false); 175 for (int i = 0; i < 12; i++) { 176 rsm.updateAppend(region, 12, 120); 177 rsm.updateAppend(region, 1002, 10020); 178 } 179 for (int i = 0; i < 13; i++) { 180 rsm.updateDeleteBatch(region, 13); 181 rsm.updateDeleteBatch(region, 1003); 182 } 183 for (int i = 0; i < 14; i++) { 184 rsm.updateGet(region, 14, 140); 185 rsm.updateGet(region, 1004, 10040); 186 } 187 for (int i = 0; i < 15; i++) { 188 rsm.updateIncrement(region, 15, 150); 189 rsm.updateIncrement(region, 1005, 10050); 190 } 191 for (int i = 0; i < 16; i++) { 192 rsm.updatePutBatch(region, 16); 193 rsm.updatePutBatch(region, 1006); 194 } 195 196 for (int i = 0; i < 17; i++) { 197 rsm.updatePut(region, 17); 198 rsm.updateDelete(region, 17); 199 rsm.updatePut(region, 1006); 200 rsm.updateDelete(region, 1003); 201 rsm.updateCheckAndDelete(region, 17); 202 rsm.updateCheckAndPut(region, 17); 203 rsm.updateCheckAndMutate(region, 17, 170); 204 } 205 206 HELPER.assertCounter("blockBytesScannedCount", 420090, serverSource); 207 HELPER.assertCounter("appendNumOps", 24, serverSource); 208 HELPER.assertCounter("appendBlockBytesScannedNumOps", 24, serverSource); 209 HELPER.assertCounter("deleteBatchNumOps", 26, serverSource); 210 HELPER.assertCounter("getNumOps", 28, serverSource); 211 HELPER.assertCounter("getBlockBytesScannedNumOps", 28, serverSource); 212 HELPER.assertCounter("incrementNumOps", 30, serverSource); 213 HELPER.assertCounter("incrementBlockBytesScannedNumOps", 30, serverSource); 214 HELPER.assertCounter("putBatchNumOps", 32, serverSource); 215 HELPER.assertCounter("putNumOps", 34, serverSource); 216 HELPER.assertCounter("deleteNumOps", 34, serverSource); 217 HELPER.assertCounter("checkAndDeleteNumOps", 17, serverSource); 218 HELPER.assertCounter("checkAndPutNumOps", 17, serverSource); 219 HELPER.assertCounter("checkAndMutateNumOps", 17, serverSource); 220 HELPER.assertCounter("checkAndMutateBlockBytesScannedNumOps", 17, serverSource); 221 222 HELPER.assertCounter("slowAppendCount", 12, serverSource); 223 HELPER.assertCounter("slowDeleteCount", 17, serverSource); 224 HELPER.assertCounter("slowGetCount", 14, serverSource); 225 HELPER.assertCounter("slowIncrementCount", 15, serverSource); 226 HELPER.assertCounter("slowPutCount", 17, serverSource); 227 } 228 229 @Test 230 public void testFlush() { 231 rsm.updateFlush(null, 1, 2, 3); 232 HELPER.assertCounter("flushTime_num_ops", 1, serverSource); 233 HELPER.assertCounter("flushMemstoreSize_num_ops", 1, serverSource); 234 HELPER.assertCounter("flushOutputSize_num_ops", 1, serverSource); 235 HELPER.assertCounter("flushedMemstoreBytes", 2, serverSource); 236 HELPER.assertCounter("flushedOutputBytes", 3, serverSource); 237 238 rsm.updateFlush(null, 10, 20, 30); 239 HELPER.assertCounter("flushTimeNumOps", 2, serverSource); 240 HELPER.assertCounter("flushMemstoreSize_num_ops", 2, serverSource); 241 HELPER.assertCounter("flushOutputSize_num_ops", 2, serverSource); 242 HELPER.assertCounter("flushedMemstoreBytes", 22, serverSource); 243 HELPER.assertCounter("flushedOutputBytes", 33, serverSource); 244 } 245 246 @Test 247 public void testCompaction() { 248 rsm.updateCompaction(null, false, 1, 2, 3, 4, 5); 249 HELPER.assertCounter("compactionTime_num_ops", 1, serverSource); 250 HELPER.assertCounter("compactionInputFileCount_num_ops", 1, serverSource); 251 HELPER.assertCounter("compactionInputSize_num_ops", 1, serverSource); 252 HELPER.assertCounter("compactionOutputFileCount_num_ops", 1, serverSource); 253 HELPER.assertCounter("compactedInputBytes", 4, serverSource); 254 HELPER.assertCounter("compactedoutputBytes", 5, serverSource); 255 256 rsm.updateCompaction(null, false, 10, 20, 30, 40, 50); 257 HELPER.assertCounter("compactionTime_num_ops", 2, serverSource); 258 HELPER.assertCounter("compactionInputFileCount_num_ops", 2, serverSource); 259 HELPER.assertCounter("compactionInputSize_num_ops", 2, serverSource); 260 HELPER.assertCounter("compactionOutputFileCount_num_ops", 2, serverSource); 261 HELPER.assertCounter("compactedInputBytes", 44, serverSource); 262 HELPER.assertCounter("compactedoutputBytes", 55, serverSource); 263 264 // do major compaction 265 rsm.updateCompaction(null, true, 100, 200, 300, 400, 500); 266 267 HELPER.assertCounter("compactionTime_num_ops", 3, serverSource); 268 HELPER.assertCounter("compactionInputFileCount_num_ops", 3, serverSource); 269 HELPER.assertCounter("compactionInputSize_num_ops", 3, serverSource); 270 HELPER.assertCounter("compactionOutputFileCount_num_ops", 3, serverSource); 271 HELPER.assertCounter("compactedInputBytes", 444, serverSource); 272 HELPER.assertCounter("compactedoutputBytes", 555, serverSource); 273 274 HELPER.assertCounter("majorCompactionTime_num_ops", 1, serverSource); 275 HELPER.assertCounter("majorCompactionInputFileCount_num_ops", 1, serverSource); 276 HELPER.assertCounter("majorCompactionInputSize_num_ops", 1, serverSource); 277 HELPER.assertCounter("majorCompactionOutputFileCount_num_ops", 1, serverSource); 278 HELPER.assertCounter("majorCompactedInputBytes", 400, serverSource); 279 HELPER.assertCounter("majorCompactedoutputBytes", 500, serverSource); 280 } 281 282 @Test 283 public void testPauseMonitor() { 284 Configuration conf = new Configuration(); 285 conf.setLong(JvmPauseMonitor.INFO_THRESHOLD_KEY, 1000L); 286 conf.setLong(JvmPauseMonitor.WARN_THRESHOLD_KEY, 10000L); 287 JvmPauseMonitor monitor = new JvmPauseMonitor(conf, serverSource); 288 monitor.updateMetrics(1500, false); 289 HELPER.assertCounter("pauseInfoThresholdExceeded", 1, serverSource); 290 HELPER.assertCounter("pauseWarnThresholdExceeded", 0, serverSource); 291 HELPER.assertCounter("pauseTimeWithoutGc_num_ops", 1, serverSource); 292 HELPER.assertCounter("pauseTimeWithGc_num_ops", 0, serverSource); 293 monitor.updateMetrics(15000, true); 294 HELPER.assertCounter("pauseInfoThresholdExceeded", 1, serverSource); 295 HELPER.assertCounter("pauseWarnThresholdExceeded", 1, serverSource); 296 HELPER.assertCounter("pauseTimeWithoutGc_num_ops", 1, serverSource); 297 HELPER.assertCounter("pauseTimeWithGc_num_ops", 1, serverSource); 298 } 299 300 @Test 301 public void testScannerMetrics() { 302 HELPER.assertCounter("scannerLeaseExpiredCount", 0, serverSource); 303 rsm.incrScannerLeaseExpired(); 304 HELPER.assertCounter("scannerLeaseExpiredCount", 1, serverSource); 305 HELPER.assertGauge("activeScanners", 0, serverSource); 306 } 307 308 @Test 309 public void testTableQueryMeterSwitch() { 310 HRegion region = mock(HRegion.class); 311 MetricsTableRequests metricsTableRequests = mock(MetricsTableRequests.class); 312 when(region.getMetricsTableRequests()).thenReturn(metricsTableRequests); 313 when(metricsTableRequests.isEnableTableLatenciesMetrics()).thenReturn(false); 314 when(metricsTableRequests.isEnabTableQueryMeterMetrics()).thenReturn(false); 315 Configuration conf = new Configuration(false); 316 // disable 317 rsm.updateReadQueryMeter(region, 500L); 318 assertFalse(HELPER.checkGaugeExists("ServerReadQueryPerSecond_count", serverSource)); 319 rsm.updateWriteQueryMeter(region, 500L); 320 assertFalse(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); 321 322 // enable 323 conf.setBoolean(MetricsRegionServer.RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY, true); 324 rsm = new MetricsRegionServer(wrapper, conf, null); 325 serverSource = rsm.getMetricsSource(); 326 rsm.updateReadQueryMeter(region, 500L); 327 assertTrue(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); 328 HELPER.assertGauge("ServerReadQueryPerSecond_count", 500L, serverSource); 329 assertTrue(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); 330 rsm.updateWriteQueryMeter(region, 500L); 331 HELPER.assertGauge("ServerWriteQueryPerSecond_count", 500L, serverSource); 332 } 333 334 @Test 335 public void testThrottleExceptionMetricsIntegration() { 336 // Record different types of throttle exceptions 337 rsm.recordThrottleException(RpcThrottlingException.Type.NumRequestsExceeded, "alice", "users"); 338 rsm.recordThrottleException(RpcThrottlingException.Type.WriteSizeExceeded, "bob", "logs"); 339 rsm.recordThrottleException(RpcThrottlingException.Type.ReadSizeExceeded, "charlie", 340 "metadata"); 341 342 // Record the same exception multiple times to test increment 343 rsm.recordThrottleException(RpcThrottlingException.Type.NumRequestsExceeded, "alice", "users"); 344 rsm.recordThrottleException(RpcThrottlingException.Type.NumRequestsExceeded, "alice", "users"); 345 346 // Verify the specific counters were created and have correct values using HELPER 347 HELPER.assertCounter("RpcThrottlingException_Type_NumRequestsExceeded_User_alice_Table_users", 348 3L, serverSource); 349 HELPER.assertCounter("RpcThrottlingException_Type_WriteSizeExceeded_User_bob_Table_logs", 1L, 350 serverSource); 351 HELPER.assertCounter("RpcThrottlingException_Type_ReadSizeExceeded_User_charlie_Table_metadata", 352 1L, serverSource); 353 354 // Test metric name sanitization through the integration 355 rsm.recordThrottleException(RpcThrottlingException.Type.RequestSizeExceeded, 356 "user.with@special", "table:with,problematic=chars"); 357 HELPER.assertCounter( 358 "RpcThrottlingException_Type_RequestSizeExceeded_User_user.with@special_Table_table_with_problematic_chars", 359 1L, serverSource); 360 361 // Test null handling through the integration 362 rsm.recordThrottleException(RpcThrottlingException.Type.ReadCapacityUnitExceeded, null, null); 363 HELPER.assertCounter( 364 "RpcThrottlingException_Type_ReadCapacityUnitExceeded_User_unknown_Table_unknown", 1L, 365 serverSource); 366 } 367}