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}