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