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; 019 020import java.util.Collections; 021import java.util.List; 022import java.util.Map; 023import java.util.stream.Collectors; 024import org.apache.hadoop.hbase.client.CompactionState; 025import org.apache.hadoop.hbase.util.Strings; 026import org.apache.yetus.audience.InterfaceAudience; 027 028import org.apache.hbase.thirdparty.com.google.common.base.Preconditions; 029import org.apache.hbase.thirdparty.com.google.protobuf.UnsafeByteOperations; 030 031import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; 032import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; 033import org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos; 034import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos; 035 036@InterfaceAudience.Private 037public final class RegionMetricsBuilder { 038 039 public static List<RegionMetrics> 040 toRegionMetrics(AdminProtos.GetRegionLoadResponse regionLoadResponse) { 041 return regionLoadResponse.getRegionLoadsList().stream() 042 .map(RegionMetricsBuilder::toRegionMetrics).collect(Collectors.toList()); 043 } 044 045 public static RegionMetrics toRegionMetrics(ClusterStatusProtos.RegionLoad regionLoadPB) { 046 return RegionMetricsBuilder 047 .newBuilder(regionLoadPB.getRegionSpecifier().getValue().toByteArray()) 048 .setBloomFilterSize(new Size(regionLoadPB.getTotalStaticBloomSizeKB(), Size.Unit.KILOBYTE)) 049 .setCompactedCellCount(regionLoadPB.getCurrentCompactedKVs()) 050 .setCompactingCellCount(regionLoadPB.getTotalCompactingKVs()) 051 .setCompletedSequenceId(regionLoadPB.getCompleteSequenceId()) 052 .setDataLocality(regionLoadPB.hasDataLocality() ? regionLoadPB.getDataLocality() : 0.0f) 053 .setDataLocalityForSsd( 054 regionLoadPB.hasDataLocalityForSsd() ? regionLoadPB.getDataLocalityForSsd() : 0.0f) 055 .setBlocksLocalWeight( 056 regionLoadPB.hasBlocksLocalWeight() ? regionLoadPB.getBlocksLocalWeight() : 0) 057 .setBlocksLocalWithSsdWeight( 058 regionLoadPB.hasBlocksLocalWithSsdWeight() ? regionLoadPB.getBlocksLocalWithSsdWeight() : 0) 059 .setBlocksTotalWeight(regionLoadPB.getBlocksTotalWeight()) 060 .setCompactionState( 061 ProtobufUtil.createCompactionStateForRegionLoad(regionLoadPB.getCompactionState())) 062 .setFilteredReadRequestCount(regionLoadPB.getFilteredReadRequestsCount()) 063 .setStoreFileUncompressedDataIndexSize( 064 new Size(regionLoadPB.getTotalStaticIndexSizeKB(), Size.Unit.KILOBYTE)) 065 .setLastMajorCompactionTimestamp(regionLoadPB.getLastMajorCompactionTs()) 066 .setMemStoreSize(new Size(regionLoadPB.getMemStoreSizeMB(), Size.Unit.MEGABYTE)) 067 .setReadRequestCount(regionLoadPB.getReadRequestsCount()) 068 .setCpRequestCount(regionLoadPB.getCpRequestsCount()) 069 .setWriteRequestCount(regionLoadPB.getWriteRequestsCount()) 070 .setStoreFileIndexSize(new Size(regionLoadPB.getStorefileIndexSizeKB(), Size.Unit.KILOBYTE)) 071 .setStoreFileRootLevelIndexSize( 072 new Size(regionLoadPB.getRootIndexSizeKB(), Size.Unit.KILOBYTE)) 073 .setStoreCount(regionLoadPB.getStores()).setStoreFileCount(regionLoadPB.getStorefiles()) 074 .setStoreRefCount(regionLoadPB.getStoreRefCount()) 075 .setMaxCompactedStoreFileRefCount(regionLoadPB.getMaxCompactedStoreFileRefCount()) 076 .setStoreFileSize(new Size(regionLoadPB.getStorefileSizeMB(), Size.Unit.MEGABYTE)) 077 .setStoreSequenceIds(regionLoadPB.getStoreCompleteSequenceIdList().stream() 078 .collect(Collectors.toMap( 079 (ClusterStatusProtos.StoreSequenceId s) -> s.getFamilyName().toByteArray(), 080 ClusterStatusProtos.StoreSequenceId::getSequenceId))) 081 .setUncompressedStoreFileSize( 082 new Size(regionLoadPB.getStoreUncompressedSizeMB(), Size.Unit.MEGABYTE)) 083 .build(); 084 } 085 086 private static List<ClusterStatusProtos.StoreSequenceId> 087 toStoreSequenceId(Map<byte[], Long> ids) { 088 return ids.entrySet().stream() 089 .map(e -> ClusterStatusProtos.StoreSequenceId.newBuilder() 090 .setFamilyName(UnsafeByteOperations.unsafeWrap(e.getKey())).setSequenceId(e.getValue()) 091 .build()) 092 .collect(Collectors.toList()); 093 } 094 095 public static ClusterStatusProtos.RegionLoad toRegionLoad(RegionMetrics regionMetrics) { 096 return ClusterStatusProtos.RegionLoad.newBuilder() 097 .setRegionSpecifier(HBaseProtos.RegionSpecifier.newBuilder() 098 .setType(HBaseProtos.RegionSpecifier.RegionSpecifierType.REGION_NAME) 099 .setValue(UnsafeByteOperations.unsafeWrap(regionMetrics.getRegionName())).build()) 100 .setTotalStaticBloomSizeKB((int) regionMetrics.getBloomFilterSize().get(Size.Unit.KILOBYTE)) 101 .setCurrentCompactedKVs(regionMetrics.getCompactedCellCount()) 102 .setTotalCompactingKVs(regionMetrics.getCompactingCellCount()) 103 .setCompleteSequenceId(regionMetrics.getCompletedSequenceId()) 104 .setDataLocality(regionMetrics.getDataLocality()) 105 .setFilteredReadRequestsCount(regionMetrics.getFilteredReadRequestCount()) 106 .setTotalStaticIndexSizeKB( 107 (int) regionMetrics.getStoreFileUncompressedDataIndexSize().get(Size.Unit.KILOBYTE)) 108 .setLastMajorCompactionTs(regionMetrics.getLastMajorCompactionTimestamp()) 109 .setMemStoreSizeMB((int) regionMetrics.getMemStoreSize().get(Size.Unit.MEGABYTE)) 110 .setReadRequestsCount(regionMetrics.getReadRequestCount()) 111 .setCpRequestsCount(regionMetrics.getCpRequestCount()) 112 .setWriteRequestsCount(regionMetrics.getWriteRequestCount()) 113 .setStorefileIndexSizeKB((long) regionMetrics.getStoreFileIndexSize().get(Size.Unit.KILOBYTE)) 114 .setRootIndexSizeKB( 115 (int) regionMetrics.getStoreFileRootLevelIndexSize().get(Size.Unit.KILOBYTE)) 116 .setStores(regionMetrics.getStoreCount()).setStorefiles(regionMetrics.getStoreFileCount()) 117 .setStoreRefCount(regionMetrics.getStoreRefCount()) 118 .setMaxCompactedStoreFileRefCount(regionMetrics.getMaxCompactedStoreFileRefCount()) 119 .setStorefileSizeMB((int) regionMetrics.getStoreFileSize().get(Size.Unit.MEGABYTE)) 120 .addAllStoreCompleteSequenceId(toStoreSequenceId(regionMetrics.getStoreSequenceId())) 121 .setStoreUncompressedSizeMB( 122 (int) regionMetrics.getUncompressedStoreFileSize().get(Size.Unit.MEGABYTE)) 123 .build(); 124 } 125 126 public static RegionMetricsBuilder newBuilder(byte[] name) { 127 return new RegionMetricsBuilder(name); 128 } 129 130 private final byte[] name; 131 private int storeCount; 132 private int storeFileCount; 133 private int storeRefCount; 134 private int maxCompactedStoreFileRefCount; 135 private long compactingCellCount; 136 private long compactedCellCount; 137 private Size storeFileSize = Size.ZERO; 138 private Size memStoreSize = Size.ZERO; 139 private Size indexSize = Size.ZERO; 140 private Size rootLevelIndexSize = Size.ZERO; 141 private Size uncompressedDataIndexSize = Size.ZERO; 142 private Size bloomFilterSize = Size.ZERO; 143 private Size uncompressedStoreFileSize = Size.ZERO; 144 private long writeRequestCount; 145 private long readRequestCount; 146 private long cpRequestCount; 147 private long filteredReadRequestCount; 148 private long completedSequenceId; 149 private Map<byte[], Long> storeSequenceIds = Collections.emptyMap(); 150 private float dataLocality; 151 private long lastMajorCompactionTimestamp; 152 private float dataLocalityForSsd; 153 private long blocksLocalWeight; 154 private long blocksLocalWithSsdWeight; 155 private long blocksTotalWeight; 156 private CompactionState compactionState; 157 158 private RegionMetricsBuilder(byte[] name) { 159 this.name = name; 160 } 161 162 public RegionMetricsBuilder setStoreCount(int value) { 163 this.storeCount = value; 164 return this; 165 } 166 167 public RegionMetricsBuilder setStoreFileCount(int value) { 168 this.storeFileCount = value; 169 return this; 170 } 171 172 public RegionMetricsBuilder setStoreRefCount(int value) { 173 this.storeRefCount = value; 174 return this; 175 } 176 177 public RegionMetricsBuilder setMaxCompactedStoreFileRefCount(int value) { 178 this.maxCompactedStoreFileRefCount = value; 179 return this; 180 } 181 182 public RegionMetricsBuilder setCompactingCellCount(long value) { 183 this.compactingCellCount = value; 184 return this; 185 } 186 187 public RegionMetricsBuilder setCompactedCellCount(long value) { 188 this.compactedCellCount = value; 189 return this; 190 } 191 192 public RegionMetricsBuilder setStoreFileSize(Size value) { 193 this.storeFileSize = value; 194 return this; 195 } 196 197 public RegionMetricsBuilder setMemStoreSize(Size value) { 198 this.memStoreSize = value; 199 return this; 200 } 201 202 public RegionMetricsBuilder setStoreFileIndexSize(Size value) { 203 this.indexSize = value; 204 return this; 205 } 206 207 public RegionMetricsBuilder setStoreFileRootLevelIndexSize(Size value) { 208 this.rootLevelIndexSize = value; 209 return this; 210 } 211 212 public RegionMetricsBuilder setStoreFileUncompressedDataIndexSize(Size value) { 213 this.uncompressedDataIndexSize = value; 214 return this; 215 } 216 217 public RegionMetricsBuilder setBloomFilterSize(Size value) { 218 this.bloomFilterSize = value; 219 return this; 220 } 221 222 public RegionMetricsBuilder setUncompressedStoreFileSize(Size value) { 223 this.uncompressedStoreFileSize = value; 224 return this; 225 } 226 227 public RegionMetricsBuilder setWriteRequestCount(long value) { 228 this.writeRequestCount = value; 229 return this; 230 } 231 232 public RegionMetricsBuilder setReadRequestCount(long value) { 233 this.readRequestCount = value; 234 return this; 235 } 236 237 public RegionMetricsBuilder setCpRequestCount(long value) { 238 this.cpRequestCount = value; 239 return this; 240 } 241 242 public RegionMetricsBuilder setFilteredReadRequestCount(long value) { 243 this.filteredReadRequestCount = value; 244 return this; 245 } 246 247 public RegionMetricsBuilder setCompletedSequenceId(long value) { 248 this.completedSequenceId = value; 249 return this; 250 } 251 252 public RegionMetricsBuilder setStoreSequenceIds(Map<byte[], Long> value) { 253 this.storeSequenceIds = value; 254 return this; 255 } 256 257 public RegionMetricsBuilder setDataLocality(float value) { 258 this.dataLocality = value; 259 return this; 260 } 261 262 public RegionMetricsBuilder setLastMajorCompactionTimestamp(long value) { 263 this.lastMajorCompactionTimestamp = value; 264 return this; 265 } 266 267 public RegionMetricsBuilder setDataLocalityForSsd(float value) { 268 this.dataLocalityForSsd = value; 269 return this; 270 } 271 272 public RegionMetricsBuilder setBlocksLocalWeight(long value) { 273 this.blocksLocalWeight = value; 274 return this; 275 } 276 277 public RegionMetricsBuilder setBlocksLocalWithSsdWeight(long value) { 278 this.blocksLocalWithSsdWeight = value; 279 return this; 280 } 281 282 public RegionMetricsBuilder setBlocksTotalWeight(long value) { 283 this.blocksTotalWeight = value; 284 return this; 285 } 286 287 public RegionMetricsBuilder setCompactionState(CompactionState compactionState) { 288 this.compactionState = compactionState; 289 return this; 290 } 291 292 public RegionMetrics build() { 293 return new RegionMetricsImpl(name, storeCount, storeFileCount, storeRefCount, 294 maxCompactedStoreFileRefCount, compactingCellCount, compactedCellCount, storeFileSize, 295 memStoreSize, indexSize, rootLevelIndexSize, uncompressedDataIndexSize, bloomFilterSize, 296 uncompressedStoreFileSize, writeRequestCount, readRequestCount, cpRequestCount, 297 filteredReadRequestCount, completedSequenceId, storeSequenceIds, dataLocality, 298 lastMajorCompactionTimestamp, dataLocalityForSsd, blocksLocalWeight, blocksLocalWithSsdWeight, 299 blocksTotalWeight, compactionState); 300 } 301 302 private static class RegionMetricsImpl implements RegionMetrics { 303 private final byte[] name; 304 private final int storeCount; 305 private final int storeFileCount; 306 private final int storeRefCount; 307 private final int maxCompactedStoreFileRefCount; 308 private final long compactingCellCount; 309 private final long compactedCellCount; 310 private final Size storeFileSize; 311 private final Size memStoreSize; 312 private final Size indexSize; 313 private final Size rootLevelIndexSize; 314 private final Size uncompressedDataIndexSize; 315 private final Size bloomFilterSize; 316 private final Size uncompressedStoreFileSize; 317 private final long writeRequestCount; 318 private final long readRequestCount; 319 private final long cpRequestCount; 320 private final long filteredReadRequestCount; 321 private final long completedSequenceId; 322 private final Map<byte[], Long> storeSequenceIds; 323 private final float dataLocality; 324 private final long lastMajorCompactionTimestamp; 325 private final float dataLocalityForSsd; 326 private final long blocksLocalWeight; 327 private final long blocksLocalWithSsdWeight; 328 private final long blocksTotalWeight; 329 private final CompactionState compactionState; 330 331 RegionMetricsImpl(byte[] name, int storeCount, int storeFileCount, int storeRefCount, 332 int maxCompactedStoreFileRefCount, final long compactingCellCount, long compactedCellCount, 333 Size storeFileSize, Size memStoreSize, Size indexSize, Size rootLevelIndexSize, 334 Size uncompressedDataIndexSize, Size bloomFilterSize, Size uncompressedStoreFileSize, 335 long writeRequestCount, long readRequestCount, long cpRequestCount, 336 long filteredReadRequestCount, long completedSequenceId, Map<byte[], Long> storeSequenceIds, 337 float dataLocality, long lastMajorCompactionTimestamp, float dataLocalityForSsd, 338 long blocksLocalWeight, long blocksLocalWithSsdWeight, long blocksTotalWeight, 339 CompactionState compactionState) { 340 this.name = Preconditions.checkNotNull(name); 341 this.storeCount = storeCount; 342 this.storeFileCount = storeFileCount; 343 this.storeRefCount = storeRefCount; 344 this.maxCompactedStoreFileRefCount = maxCompactedStoreFileRefCount; 345 this.compactingCellCount = compactingCellCount; 346 this.compactedCellCount = compactedCellCount; 347 this.storeFileSize = Preconditions.checkNotNull(storeFileSize); 348 this.memStoreSize = Preconditions.checkNotNull(memStoreSize); 349 this.indexSize = Preconditions.checkNotNull(indexSize); 350 this.rootLevelIndexSize = Preconditions.checkNotNull(rootLevelIndexSize); 351 this.uncompressedDataIndexSize = Preconditions.checkNotNull(uncompressedDataIndexSize); 352 this.bloomFilterSize = Preconditions.checkNotNull(bloomFilterSize); 353 this.uncompressedStoreFileSize = Preconditions.checkNotNull(uncompressedStoreFileSize); 354 this.writeRequestCount = writeRequestCount; 355 this.readRequestCount = readRequestCount; 356 this.cpRequestCount = cpRequestCount; 357 this.filteredReadRequestCount = filteredReadRequestCount; 358 this.completedSequenceId = completedSequenceId; 359 this.storeSequenceIds = Preconditions.checkNotNull(storeSequenceIds); 360 this.dataLocality = dataLocality; 361 this.lastMajorCompactionTimestamp = lastMajorCompactionTimestamp; 362 this.dataLocalityForSsd = dataLocalityForSsd; 363 this.blocksLocalWeight = blocksLocalWeight; 364 this.blocksLocalWithSsdWeight = blocksLocalWithSsdWeight; 365 this.blocksTotalWeight = blocksTotalWeight; 366 this.compactionState = compactionState; 367 } 368 369 @Override 370 public byte[] getRegionName() { 371 return name; 372 } 373 374 @Override 375 public int getStoreCount() { 376 return storeCount; 377 } 378 379 @Override 380 public int getStoreFileCount() { 381 return storeFileCount; 382 } 383 384 @Override 385 public int getStoreRefCount() { 386 return storeRefCount; 387 } 388 389 @Override 390 public int getMaxCompactedStoreFileRefCount() { 391 return maxCompactedStoreFileRefCount; 392 } 393 394 @Override 395 public Size getStoreFileSize() { 396 return storeFileSize; 397 } 398 399 @Override 400 public Size getMemStoreSize() { 401 return memStoreSize; 402 } 403 404 @Override 405 public long getReadRequestCount() { 406 return readRequestCount; 407 } 408 409 @Override 410 public long getCpRequestCount() { 411 return cpRequestCount; 412 } 413 414 @Override 415 public long getFilteredReadRequestCount() { 416 return filteredReadRequestCount; 417 } 418 419 @Override 420 public long getWriteRequestCount() { 421 return writeRequestCount; 422 } 423 424 @Override 425 public Size getStoreFileIndexSize() { 426 return indexSize; 427 } 428 429 @Override 430 public Size getStoreFileRootLevelIndexSize() { 431 return rootLevelIndexSize; 432 } 433 434 @Override 435 public Size getStoreFileUncompressedDataIndexSize() { 436 return uncompressedDataIndexSize; 437 } 438 439 @Override 440 public Size getBloomFilterSize() { 441 return bloomFilterSize; 442 } 443 444 @Override 445 public long getCompactingCellCount() { 446 return compactingCellCount; 447 } 448 449 @Override 450 public long getCompactedCellCount() { 451 return compactedCellCount; 452 } 453 454 @Override 455 public long getCompletedSequenceId() { 456 return completedSequenceId; 457 } 458 459 @Override 460 public Map<byte[], Long> getStoreSequenceId() { 461 return Collections.unmodifiableMap(storeSequenceIds); 462 } 463 464 @Override 465 public Size getUncompressedStoreFileSize() { 466 return uncompressedStoreFileSize; 467 } 468 469 @Override 470 public float getDataLocality() { 471 return dataLocality; 472 } 473 474 @Override 475 public long getLastMajorCompactionTimestamp() { 476 return lastMajorCompactionTimestamp; 477 } 478 479 @Override 480 public float getDataLocalityForSsd() { 481 return dataLocalityForSsd; 482 } 483 484 @Override 485 public long getBlocksLocalWeight() { 486 return blocksLocalWeight; 487 } 488 489 @Override 490 public long getBlocksLocalWithSsdWeight() { 491 return blocksLocalWithSsdWeight; 492 } 493 494 @Override 495 public long getBlocksTotalWeight() { 496 return blocksTotalWeight; 497 } 498 499 @Override 500 public CompactionState getCompactionState() { 501 return compactionState; 502 } 503 504 @Override 505 public String toString() { 506 StringBuilder sb = 507 Strings.appendKeyValue(new StringBuilder(), "storeCount", this.getStoreCount()); 508 Strings.appendKeyValue(sb, "storeFileCount", this.getStoreFileCount()); 509 Strings.appendKeyValue(sb, "storeRefCount", this.getStoreRefCount()); 510 Strings.appendKeyValue(sb, "maxCompactedStoreFileRefCount", 511 this.getMaxCompactedStoreFileRefCount()); 512 Strings.appendKeyValue(sb, "uncompressedStoreFileSize", this.getUncompressedStoreFileSize()); 513 Strings.appendKeyValue(sb, "lastMajorCompactionTimestamp", 514 this.getLastMajorCompactionTimestamp()); 515 Strings.appendKeyValue(sb, "storeFileSize", this.getStoreFileSize()); 516 if (this.getUncompressedStoreFileSize().get() != 0) { 517 Strings.appendKeyValue(sb, "compressionRatio", 518 String.format("%.4f", (float) this.getStoreFileSize().get(Size.Unit.MEGABYTE) 519 / (float) this.getUncompressedStoreFileSize().get(Size.Unit.MEGABYTE))); 520 } 521 Strings.appendKeyValue(sb, "memStoreSize", this.getMemStoreSize()); 522 Strings.appendKeyValue(sb, "readRequestCount", this.getReadRequestCount()); 523 Strings.appendKeyValue(sb, "cpRequestCount", this.getCpRequestCount()); 524 Strings.appendKeyValue(sb, "writeRequestCount", this.getWriteRequestCount()); 525 Strings.appendKeyValue(sb, "rootLevelIndexSize", this.getStoreFileRootLevelIndexSize()); 526 Strings.appendKeyValue(sb, "uncompressedDataIndexSize", 527 this.getStoreFileUncompressedDataIndexSize()); 528 Strings.appendKeyValue(sb, "bloomFilterSize", this.getBloomFilterSize()); 529 Strings.appendKeyValue(sb, "compactingCellCount", this.getCompactingCellCount()); 530 Strings.appendKeyValue(sb, "compactedCellCount", this.getCompactedCellCount()); 531 float compactionProgressPct = Float.NaN; 532 if (this.getCompactingCellCount() > 0) { 533 compactionProgressPct = 534 ((float) this.getCompactedCellCount() / (float) this.getCompactingCellCount()); 535 } 536 Strings.appendKeyValue(sb, "compactionProgressPct", compactionProgressPct); 537 Strings.appendKeyValue(sb, "completedSequenceId", this.getCompletedSequenceId()); 538 Strings.appendKeyValue(sb, "dataLocality", this.getDataLocality()); 539 Strings.appendKeyValue(sb, "dataLocalityForSsd", this.getDataLocalityForSsd()); 540 Strings.appendKeyValue(sb, "blocksLocalWeight", blocksLocalWeight); 541 Strings.appendKeyValue(sb, "blocksLocalWithSsdWeight", blocksLocalWithSsdWeight); 542 Strings.appendKeyValue(sb, "blocksTotalWeight", blocksTotalWeight); 543 Strings.appendKeyValue(sb, "compactionState", compactionState); 544 return sb.toString(); 545 } 546 } 547 548}