hbase-client/src/main/java/org/apache/hadoop/hbase/RegionMetricsBuilder.java

   1 /**
   2  * Copyright The Apache Software Foundation
   3  *
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 package org.apache.hadoop.hbase;
  22
  23 import java.util.Collections;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.stream.Collectors;
  27 import org.apache.hadoop.hbase.client.CompactionState;
  28 import org.apache.hadoop.hbase.util.Strings;
  29 import org.apache.yetus.audience.InterfaceAudience;
  30
  31 import org.apache.hbase.thirdparty.com.google.common.base.Preconditions;
  32 import org.apache.hbase.thirdparty.com.google.protobuf.UnsafeByteOperations;
  33
  34 import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil;
  35 import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos;
  36 import org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos;
  37 import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos;
  38
  39 @InterfaceAudience.Private
  40 public final class RegionMetricsBuilder {
  41
  42   public static List<RegionMetrics> toRegionMetrics(
  43       AdminProtos.GetRegionLoadResponse regionLoadResponse) {
  44     return regionLoadResponse.getRegionLoadsList().stream()
  45         .map(RegionMetricsBuilder::toRegionMetrics).collect(Collectors.toList());
  46   }
  47
  48   public static RegionMetrics toRegionMetrics(ClusterStatusProtos.RegionLoad regionLoadPB) {
  49     return RegionMetricsBuilder
  50         .newBuilder(regionLoadPB.getRegionSpecifier().getValue().toByteArray())
  51         .setBloomFilterSize(new Size(regionLoadPB.getTotalStaticBloomSizeKB(), Size.Unit.KILOBYTE))
  52         .setCompactedCellCount(regionLoadPB.getCurrentCompactedKVs())
  53         .setCompactingCellCount(regionLoadPB.getTotalCompactingKVs())
  54         .setCompletedSequenceId(regionLoadPB.getCompleteSequenceId())
  55         .setDataLocality(regionLoadPB.hasDataLocality() ? regionLoadPB.getDataLocality() : 0.0f)
  56         .setDataLocalityForSsd(regionLoadPB.hasDataLocalityForSsd() ?
  57           regionLoadPB.getDataLocalityForSsd() : 0.0f)
  58         .setBlocksLocalWeight(regionLoadPB.hasBlocksLocalWeight() ?
  59           regionLoadPB.getBlocksLocalWeight() : 0)
  60         .setBlocksLocalWithSsdWeight(regionLoadPB.hasBlocksLocalWithSsdWeight() ?
  61           regionLoadPB.getBlocksLocalWithSsdWeight() : 0)
  62         .setBlocksTotalWeight(regionLoadPB.getBlocksTotalWeight())
  63         .setCompactionState(ProtobufUtil.createCompactionStateForRegionLoad(
  64           regionLoadPB.getCompactionState()))
  65         .setFilteredReadRequestCount(regionLoadPB.getFilteredReadRequestsCount())
  66         .setStoreFileUncompressedDataIndexSize(new Size(regionLoadPB.getTotalStaticIndexSizeKB(),
  67           Size.Unit.KILOBYTE))
  68         .setLastMajorCompactionTimestamp(regionLoadPB.getLastMajorCompactionTs())
  69         .setMemStoreSize(new Size(regionLoadPB.getMemStoreSizeMB(), Size.Unit.MEGABYTE))
  70         .setReadRequestCount(regionLoadPB.getReadRequestsCount())
  71         .setCpRequestCount(regionLoadPB.getCpRequestsCount())
  72         .setWriteRequestCount(regionLoadPB.getWriteRequestsCount())
  73         .setStoreFileIndexSize(new Size(regionLoadPB.getStorefileIndexSizeKB(),
  74           Size.Unit.KILOBYTE))
  75         .setStoreFileRootLevelIndexSize(new Size(regionLoadPB.getRootIndexSizeKB(),
  76           Size.Unit.KILOBYTE))
  77         .setStoreCount(regionLoadPB.getStores())
  78         .setStoreFileCount(regionLoadPB.getStorefiles())
  79         .setStoreRefCount(regionLoadPB.getStoreRefCount())
  80         .setMaxCompactedStoreFileRefCount(regionLoadPB.getMaxCompactedStoreFileRefCount())
  81         .setStoreFileSize(new Size(regionLoadPB.getStorefileSizeMB(), Size.Unit.MEGABYTE))
  82         .setStoreSequenceIds(regionLoadPB.getStoreCompleteSequenceIdList().stream()
  83           .collect(Collectors.toMap(
  84             (ClusterStatusProtos.StoreSequenceId s) -> s.getFamilyName().toByteArray(),
  85               ClusterStatusProtos.StoreSequenceId::getSequenceId)))
  86         .setUncompressedStoreFileSize(
  87           new Size(regionLoadPB.getStoreUncompressedSizeMB(),Size.Unit.MEGABYTE))
  88         .build();
  89   }
  90
  91   private static List<ClusterStatusProtos.StoreSequenceId> toStoreSequenceId(
  92       Map<byte[], Long> ids) {
  93     return ids.entrySet().stream()
  94         .map(e -> ClusterStatusProtos.StoreSequenceId.newBuilder()
  95           .setFamilyName(UnsafeByteOperations.unsafeWrap(e.getKey()))
  96           .setSequenceId(e.getValue())
  97           .build())
  98         .collect(Collectors.toList());
  99   }
 100
 101   public static ClusterStatusProtos.RegionLoad toRegionLoad(RegionMetrics regionMetrics) {
 102     return ClusterStatusProtos.RegionLoad.newBuilder()
 103         .setRegionSpecifier(HBaseProtos.RegionSpecifier
 104           .newBuilder().setType(HBaseProtos.RegionSpecifier.RegionSpecifierType.REGION_NAME)
 105           .setValue(UnsafeByteOperations.unsafeWrap(regionMetrics.getRegionName()))
 106           .build())
 107         .setTotalStaticBloomSizeKB((int) regionMetrics.getBloomFilterSize()
 108           .get(Size.Unit.KILOBYTE))
 109         .setCurrentCompactedKVs(regionMetrics.getCompactedCellCount())
 110         .setTotalCompactingKVs(regionMetrics.getCompactingCellCount())
 111         .setCompleteSequenceId(regionMetrics.getCompletedSequenceId())
 112         .setDataLocality(regionMetrics.getDataLocality())
 113         .setFilteredReadRequestsCount(regionMetrics.getFilteredReadRequestCount())
 114         .setTotalStaticIndexSizeKB((int) regionMetrics.getStoreFileUncompressedDataIndexSize()
 115           .get(Size.Unit.KILOBYTE))
 116         .setLastMajorCompactionTs(regionMetrics.getLastMajorCompactionTimestamp())
 117         .setMemStoreSizeMB((int) regionMetrics.getMemStoreSize().get(Size.Unit.MEGABYTE))
 118         .setReadRequestsCount(regionMetrics.getReadRequestCount())
 119         .setCpRequestsCount(regionMetrics.getCpRequestCount())
 120         .setWriteRequestsCount(regionMetrics.getWriteRequestCount())
 121         .setStorefileIndexSizeKB((long) regionMetrics.getStoreFileIndexSize()
 122           .get(Size.Unit.KILOBYTE))
 123         .setRootIndexSizeKB((int) regionMetrics.getStoreFileRootLevelIndexSize()
 124           .get(Size.Unit.KILOBYTE))
 125         .setStores(regionMetrics.getStoreCount())
 126         .setStorefiles(regionMetrics.getStoreFileCount())
 127         .setStoreRefCount(regionMetrics.getStoreRefCount())
 128         .setMaxCompactedStoreFileRefCount(regionMetrics.getMaxCompactedStoreFileRefCount())
 129         .setStorefileSizeMB((int) regionMetrics.getStoreFileSize().get(Size.Unit.MEGABYTE))
 130         .addAllStoreCompleteSequenceId(toStoreSequenceId(regionMetrics.getStoreSequenceId()))
 131         .setStoreUncompressedSizeMB(
 132           (int) regionMetrics.getUncompressedStoreFileSize().get(Size.Unit.MEGABYTE))
 133         .build();
 134   }
 135
 136   public static RegionMetricsBuilder newBuilder(byte[] name) {
 137     return new RegionMetricsBuilder(name);
 138   }
 139
 140   private final byte[] name;
 141   private int storeCount;
 142   private int storeFileCount;
 143   private int storeRefCount;
 144   private int maxCompactedStoreFileRefCount;
 145   private long compactingCellCount;
 146   private long compactedCellCount;
 147   private Size storeFileSize = Size.ZERO;
 148   private Size memStoreSize = Size.ZERO;
 149   private Size indexSize = Size.ZERO;
 150   private Size rootLevelIndexSize = Size.ZERO;
 151   private Size uncompressedDataIndexSize = Size.ZERO;
 152   private Size bloomFilterSize = Size.ZERO;
 153   private Size uncompressedStoreFileSize = Size.ZERO;
 154   private long writeRequestCount;
 155   private long readRequestCount;
 156   private long cpRequestCount;
 157   private long filteredReadRequestCount;
 158   private long completedSequenceId;
 159   private Map<byte[], Long> storeSequenceIds = Collections.emptyMap();
 160   private float dataLocality;
 161   private long lastMajorCompactionTimestamp;
 162   private float dataLocalityForSsd;
 163   private long blocksLocalWeight;
 164   private long blocksLocalWithSsdWeight;
 165   private long blocksTotalWeight;
 166   private CompactionState compactionState;
 167   private RegionMetricsBuilder(byte[] name) {
 168     this.name = name;
 169   }
 170
 171   public RegionMetricsBuilder setStoreCount(int value) {
 172     this.storeCount = value;
 173     return this;
 174   }
 175   public RegionMetricsBuilder setStoreFileCount(int value) {
 176     this.storeFileCount = value;
 177     return this;
 178   }
 179   public RegionMetricsBuilder setStoreRefCount(int value) {
 180     this.storeRefCount = value;
 181     return this;
 182   }
 183   public RegionMetricsBuilder setMaxCompactedStoreFileRefCount(int value) {
 184     this.maxCompactedStoreFileRefCount = value;
 185     return this;
 186   }
 187   public RegionMetricsBuilder setCompactingCellCount(long value) {
 188     this.compactingCellCount = value;
 189     return this;
 190   }
 191   public RegionMetricsBuilder setCompactedCellCount(long value) {
 192     this.compactedCellCount = value;
 193     return this;
 194   }
 195   public RegionMetricsBuilder setStoreFileSize(Size value) {
 196     this.storeFileSize = value;
 197     return this;
 198   }
 199   public RegionMetricsBuilder setMemStoreSize(Size value) {
 200     this.memStoreSize = value;
 201     return this;
 202   }
 203   public RegionMetricsBuilder setStoreFileIndexSize(Size value) {
 204     this.indexSize = value;
 205     return this;
 206   }
 207   public RegionMetricsBuilder setStoreFileRootLevelIndexSize(Size value) {
 208     this.rootLevelIndexSize = value;
 209     return this;
 210   }
 211   public RegionMetricsBuilder setStoreFileUncompressedDataIndexSize(Size value) {
 212     this.uncompressedDataIndexSize = value;
 213     return this;
 214   }
 215   public RegionMetricsBuilder setBloomFilterSize(Size value) {
 216     this.bloomFilterSize = value;
 217     return this;
 218   }
 219   public RegionMetricsBuilder setUncompressedStoreFileSize(Size value) {
 220     this.uncompressedStoreFileSize = value;
 221     return this;
 222   }
 223   public RegionMetricsBuilder setWriteRequestCount(long value) {
 224     this.writeRequestCount = value;
 225     return this;
 226   }
 227   public RegionMetricsBuilder setReadRequestCount(long value) {
 228     this.readRequestCount = value;
 229     return this;
 230   }
 231   public RegionMetricsBuilder setCpRequestCount(long value) {
 232     this.cpRequestCount = value;
 233     return this;
 234   }
 235   public RegionMetricsBuilder setFilteredReadRequestCount(long value) {
 236     this.filteredReadRequestCount = value;
 237     return this;
 238   }
 239   public RegionMetricsBuilder setCompletedSequenceId(long value) {
 240     this.completedSequenceId = value;
 241     return this;
 242   }
 243   public RegionMetricsBuilder setStoreSequenceIds(Map<byte[], Long> value) {
 244     this.storeSequenceIds = value;
 245     return this;
 246   }
 247   public RegionMetricsBuilder setDataLocality(float value) {
 248     this.dataLocality = value;
 249     return this;
 250   }
 251   public RegionMetricsBuilder setLastMajorCompactionTimestamp(long value) {
 252     this.lastMajorCompactionTimestamp = value;
 253     return this;
 254   }
 255   public RegionMetricsBuilder setDataLocalityForSsd(float value) {
 256     this.dataLocalityForSsd = value;
 257     return this;
 258   }
 259   public RegionMetricsBuilder setBlocksLocalWeight(long value) {
 260     this.blocksLocalWeight = value;
 261     return this;
 262   }
 263   public RegionMetricsBuilder setBlocksLocalWithSsdWeight(long value) {
 264     this.blocksLocalWithSsdWeight = value;
 265     return this;
 266   }
 267   public RegionMetricsBuilder setBlocksTotalWeight(long value) {
 268     this.blocksTotalWeight = value;
 269     return this;
 270   }
 271   public RegionMetricsBuilder setCompactionState(CompactionState compactionState) {
 272     this.compactionState = compactionState;
 273     return this;
 274   }
 275
 276   public RegionMetrics build() {
 277     return new RegionMetricsImpl(name,
 278         storeCount,
 279         storeFileCount,
 280         storeRefCount,
 281         maxCompactedStoreFileRefCount,
 282         compactingCellCount,
 283         compactedCellCount,
 284         storeFileSize,
 285         memStoreSize,
 286         indexSize,
 287         rootLevelIndexSize,
 288         uncompressedDataIndexSize,
 289         bloomFilterSize,
 290         uncompressedStoreFileSize,
 291         writeRequestCount,
 292         readRequestCount,
 293         cpRequestCount,
 294         filteredReadRequestCount,
 295         completedSequenceId,
 296         storeSequenceIds,
 297         dataLocality,
 298         lastMajorCompactionTimestamp,
 299         dataLocalityForSsd,
 300         blocksLocalWeight,
 301         blocksLocalWithSsdWeight,
 302         blocksTotalWeight,
 303         compactionState);
 304   }
 305
 306   private static class RegionMetricsImpl implements RegionMetrics {
 307     private final byte[] name;
 308     private final int storeCount;
 309     private final int storeFileCount;
 310     private final int storeRefCount;
 311     private final int maxCompactedStoreFileRefCount;
 312     private final long compactingCellCount;
 313     private final long compactedCellCount;
 314     private final Size storeFileSize;
 315     private final Size memStoreSize;
 316     private final Size indexSize;
 317     private final Size rootLevelIndexSize;
 318     private final Size uncompressedDataIndexSize;
 319     private final Size bloomFilterSize;
 320     private final Size uncompressedStoreFileSize;
 321     private final long writeRequestCount;
 322     private final long readRequestCount;
 323     private final long cpRequestCount;
 324     private final long filteredReadRequestCount;
 325     private final long completedSequenceId;
 326     private final Map<byte[], Long> storeSequenceIds;
 327     private final float dataLocality;
 328     private final long lastMajorCompactionTimestamp;
 329     private final float dataLocalityForSsd;
 330     private final long blocksLocalWeight;
 331     private final long blocksLocalWithSsdWeight;
 332     private final long blocksTotalWeight;
 333     private final CompactionState compactionState;
 334     RegionMetricsImpl(byte[] name,
 335         int storeCount,
 336         int storeFileCount,
 337         int storeRefCount,
 338         int maxCompactedStoreFileRefCount,
 339         final long compactingCellCount,
 340         long compactedCellCount,
 341         Size storeFileSize,
 342         Size memStoreSize,
 343         Size indexSize,
 344         Size rootLevelIndexSize,
 345         Size uncompressedDataIndexSize,
 346         Size bloomFilterSize,
 347         Size uncompressedStoreFileSize,
 348         long writeRequestCount,
 349         long readRequestCount,
 350         long cpRequestCount,
 351         long filteredReadRequestCount,
 352         long completedSequenceId,
 353         Map<byte[], Long> storeSequenceIds,
 354         float dataLocality,
 355         long lastMajorCompactionTimestamp,
 356         float dataLocalityForSsd,
 357         long blocksLocalWeight,
 358         long blocksLocalWithSsdWeight,
 359         long blocksTotalWeight,
 360         CompactionState compactionState) {
 361       this.name = Preconditions.checkNotNull(name);
 362       this.storeCount = storeCount;
 363       this.storeFileCount = storeFileCount;
 364       this.storeRefCount = storeRefCount;
 365       this.maxCompactedStoreFileRefCount = maxCompactedStoreFileRefCount;
 366       this.compactingCellCount = compactingCellCount;
 367       this.compactedCellCount = compactedCellCount;
 368       this.storeFileSize = Preconditions.checkNotNull(storeFileSize);
 369       this.memStoreSize = Preconditions.checkNotNull(memStoreSize);
 370       this.indexSize = Preconditions.checkNotNull(indexSize);
 371       this.rootLevelIndexSize = Preconditions.checkNotNull(rootLevelIndexSize);
 372       this.uncompressedDataIndexSize = Preconditions.checkNotNull(uncompressedDataIndexSize);
 373       this.bloomFilterSize = Preconditions.checkNotNull(bloomFilterSize);
 374       this.uncompressedStoreFileSize = Preconditions.checkNotNull(uncompressedStoreFileSize);
 375       this.writeRequestCount = writeRequestCount;
 376       this.readRequestCount = readRequestCount;
 377       this.cpRequestCount = cpRequestCount;
 378       this.filteredReadRequestCount = filteredReadRequestCount;
 379       this.completedSequenceId = completedSequenceId;
 380       this.storeSequenceIds = Preconditions.checkNotNull(storeSequenceIds);
 381       this.dataLocality = dataLocality;
 382       this.lastMajorCompactionTimestamp = lastMajorCompactionTimestamp;
 383       this.dataLocalityForSsd = dataLocalityForSsd;
 384       this.blocksLocalWeight = blocksLocalWeight;
 385       this.blocksLocalWithSsdWeight = blocksLocalWithSsdWeight;
 386       this.blocksTotalWeight = blocksTotalWeight;
 387       this.compactionState = compactionState;
 388     }
 389
 390     @Override
 391     public byte[] getRegionName() {
 392       return name;
 393     }
 394
 395     @Override
 396     public int getStoreCount() {
 397       return storeCount;
 398     }
 399
 400     @Override
 401     public int getStoreFileCount() {
 402       return storeFileCount;
 403     }
 404
 405     @Override
 406     public int getStoreRefCount() {
 407       return storeRefCount;
 408     }
 409
 410     @Override
 411     public int getMaxCompactedStoreFileRefCount() {
 412       return maxCompactedStoreFileRefCount;
 413     }
 414
 415     @Override
 416     public Size getStoreFileSize() {
 417       return storeFileSize;
 418     }
 419
 420     @Override
 421     public Size getMemStoreSize() {
 422       return memStoreSize;
 423     }
 424
 425     @Override
 426     public long getReadRequestCount() {
 427       return readRequestCount;
 428     }
 429
 430     @Override
 431     public long getCpRequestCount() {
 432       return cpRequestCount;
 433     }
 434
 435     @Override
 436     public long getFilteredReadRequestCount() {
 437       return filteredReadRequestCount;
 438     }
 439
 440     @Override
 441     public long getWriteRequestCount() {
 442       return writeRequestCount;
 443     }
 444
 445     @Override
 446     public Size getStoreFileIndexSize() {
 447       return indexSize;
 448     }
 449
 450     @Override
 451     public Size getStoreFileRootLevelIndexSize() {
 452       return rootLevelIndexSize;
 453     }
 454
 455     @Override
 456     public Size getStoreFileUncompressedDataIndexSize() {
 457       return uncompressedDataIndexSize;
 458     }
 459
 460     @Override
 461     public Size getBloomFilterSize() {
 462       return bloomFilterSize;
 463     }
 464
 465     @Override
 466     public long getCompactingCellCount() {
 467       return compactingCellCount;
 468     }
 469
 470     @Override
 471     public long getCompactedCellCount() {
 472       return compactedCellCount;
 473     }
 474
 475     @Override
 476     public long getCompletedSequenceId() {
 477       return completedSequenceId;
 478     }
 479
 480     @Override
 481     public Map<byte[], Long> getStoreSequenceId() {
 482       return Collections.unmodifiableMap(storeSequenceIds);
 483     }
 484
 485     @Override
 486     public Size getUncompressedStoreFileSize() {
 487       return uncompressedStoreFileSize;
 488     }
 489
 490     @Override
 491     public float getDataLocality() {
 492       return dataLocality;
 493     }
 494
 495     @Override
 496     public long getLastMajorCompactionTimestamp() {
 497       return lastMajorCompactionTimestamp;
 498     }
 499
 500     @Override
 501     public float getDataLocalityForSsd() {
 502       return dataLocalityForSsd;
 503     }
 504
 505     @Override
 506     public long getBlocksLocalWeight() {
 507       return blocksLocalWeight;
 508     }
 509
 510     @Override
 511     public long getBlocksLocalWithSsdWeight() {
 512       return blocksLocalWithSsdWeight;
 513     }
 514
 515     @Override
 516     public long getBlocksTotalWeight() {
 517       return blocksTotalWeight;
 518     }
 519
 520     @Override
 521     public CompactionState getCompactionState() {
 522       return compactionState;
 523     }
 524
 525     @Override
 526     public String toString() {
 527       StringBuilder sb = Strings.appendKeyValue(new StringBuilder(), "storeCount",
 528           this.getStoreCount());
 529       Strings.appendKeyValue(sb, "storeFileCount",
 530           this.getStoreFileCount());
 531       Strings.appendKeyValue(sb, "storeRefCount",
 532         this.getStoreRefCount());
 533       Strings.appendKeyValue(sb, "maxCompactedStoreFileRefCount",
 534         this.getMaxCompactedStoreFileRefCount());
 535       Strings.appendKeyValue(sb, "uncompressedStoreFileSize",
 536           this.getUncompressedStoreFileSize());
 537       Strings.appendKeyValue(sb, "lastMajorCompactionTimestamp",
 538           this.getLastMajorCompactionTimestamp());
 539       Strings.appendKeyValue(sb, "storeFileSize",
 540           this.getStoreFileSize());
 541       if (this.getUncompressedStoreFileSize().get() != 0) {
 542         Strings.appendKeyValue(sb, "compressionRatio",
 543             String.format("%.4f",
 544                 (float) this.getStoreFileSize().get(Size.Unit.MEGABYTE) /
 545                 (float) this.getUncompressedStoreFileSize().get(Size.Unit.MEGABYTE)));
 546       }
 547       Strings.appendKeyValue(sb, "memStoreSize",
 548           this.getMemStoreSize());
 549       Strings.appendKeyValue(sb, "readRequestCount",
 550           this.getReadRequestCount());
 551       Strings.appendKeyValue(sb, "cpRequestCount",
 552           this.getCpRequestCount());
 553       Strings.appendKeyValue(sb, "writeRequestCount",
 554           this.getWriteRequestCount());
 555       Strings.appendKeyValue(sb, "rootLevelIndexSize",
 556           this.getStoreFileRootLevelIndexSize());
 557       Strings.appendKeyValue(sb, "uncompressedDataIndexSize",
 558           this.getStoreFileUncompressedDataIndexSize());
 559       Strings.appendKeyValue(sb, "bloomFilterSize",
 560           this.getBloomFilterSize());
 561       Strings.appendKeyValue(sb, "compactingCellCount",
 562           this.getCompactingCellCount());
 563       Strings.appendKeyValue(sb, "compactedCellCount",
 564           this.getCompactedCellCount());
 565       float compactionProgressPct = Float.NaN;
 566       if (this.getCompactingCellCount() > 0) {
 567         compactionProgressPct = ((float) this.getCompactedCellCount() /
 568             (float) this.getCompactingCellCount());
 569       }
 570       Strings.appendKeyValue(sb, "compactionProgressPct",
 571           compactionProgressPct);
 572       Strings.appendKeyValue(sb, "completedSequenceId",
 573           this.getCompletedSequenceId());
 574       Strings.appendKeyValue(sb, "dataLocality",
 575           this.getDataLocality());
 576       Strings.appendKeyValue(sb, "dataLocalityForSsd",
 577           this.getDataLocalityForSsd());
 578       Strings.appendKeyValue(sb, "blocksLocalWeight",
 579         blocksLocalWeight);
 580       Strings.appendKeyValue(sb, "blocksLocalWithSsdWeight",
 581         blocksLocalWithSsdWeight);
 582       Strings.appendKeyValue(sb, "blocksTotalWeight",
 583         blocksTotalWeight);
 584       Strings.appendKeyValue(sb, "compactionState",
 585         compactionState);
 586       return sb.toString();
 587     }
 588   }
 589
 590 }