diff --git a/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableLatencies.java b/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableLatencies.java deleted file mode 100644 index e7d447aef491..000000000000 --- a/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableLatencies.java +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.hadoop.hbase.regionserver; - -import org.apache.yetus.audience.InterfaceAudience; - -/** - * Latency metrics for a specific table in a RegionServer. - */ -@InterfaceAudience.Private -public interface MetricsTableLatencies { - - /** - * The name of the metrics - */ - String METRICS_NAME = "TableLatencies"; - - /** - * The name of the metrics context that metrics will be under. - */ - String METRICS_CONTEXT = "regionserver"; - - /** - * Description - */ - String METRICS_DESCRIPTION = "Metrics about Tables on a single HBase RegionServer"; - - /** - * The name of the metrics context that metrics will be under in jmx - */ - String METRICS_JMX_CONTEXT = "RegionServer,sub=" + METRICS_NAME; - - String GET_TIME = "getTime"; - String SCAN_TIME = "scanTime"; - String SCAN_SIZE = "scanSize"; - String PUT_TIME = "putTime"; - String PUT_BATCH_TIME = "putBatchTime"; - String DELETE_TIME = "deleteTime"; - String DELETE_BATCH_TIME = "deleteBatchTime"; - String INCREMENT_TIME = "incrementTime"; - String APPEND_TIME = "appendTime"; - String CHECK_AND_DELETE_TIME = "checkAndDeleteTime"; - String CHECK_AND_PUT_TIME = "checkAndPutTime"; - String CHECK_AND_MUTATE_TIME = "checkAndMutateTime"; - - /** - * Update the Put time histogram - * @param tableName The table the metric is for - * @param t time it took - */ - void updatePut(String tableName, long t); - - /** - * Update the batch Put time histogram - * @param tableName The table the metric is for - * @param t time it took - */ - void updatePutBatch(String tableName, long t); - - /** - * Update the Delete time histogram - * @param tableName The table the metric is for - * @param t time it took - */ - void updateDelete(String tableName, long t); - - /** - * Update the batch Delete time histogram - * @param tableName The table the metric is for - * @param t time it took - */ - void updateDeleteBatch(String tableName, long t); - - /** - * Update the Get time histogram . - * @param tableName The table the metric is for - * @param t time it took - */ - void updateGet(String tableName, long t); - - /** - * Update the Increment time histogram. - * @param tableName The table the metric is for - * @param t time it took - */ - void updateIncrement(String tableName, long t); - - /** - * Update the Append time histogram. - * @param tableName The table the metric is for - * @param t time it took - */ - void updateAppend(String tableName, long t); - - /** - * Update the scan size. - * @param tableName The table the metric is for - * @param scanSize size of the scan - */ - void updateScanSize(String tableName, long scanSize); - - /** - * Update the scan time. - * @param tableName The table the metric is for - * @param t time it took - */ - void updateScanTime(String tableName, long t); - - /** - * Update the CheckAndDelete time histogram. - * @param nameAsString The table the metric is for - * @param time time it took - */ - void updateCheckAndDelete(String nameAsString, long time); - - /** - * Update the CheckAndPut time histogram. - * @param nameAsString The table the metric is for - * @param time time it took - */ - void updateCheckAndPut(String nameAsString, long time); - - /** - * Update the CheckAndMutate time histogram. - * @param nameAsString The table the metric is for - * @param time time it took - */ - void updateCheckAndMutate(String nameAsString, long time); - -} diff --git a/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableQueryMeter.java b/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableQueryMeter.java deleted file mode 100644 index 1ff86de67ec5..000000000000 --- a/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableQueryMeter.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.hadoop.hbase.regionserver; - -import org.apache.hadoop.hbase.TableName; -import org.apache.yetus.audience.InterfaceAudience; - -/** - * Query Per Second for each table in a RegionServer. - */ -@InterfaceAudience.Private -public interface MetricsTableQueryMeter { - - String TABLE_READ_QUERY_PER_SECOND = "tableReadQueryPerSecond"; - String TABLE_WRITE_QUERY_PER_SECOND = "tableWriteQueryPerSecond"; - - /** - * Update table read QPS - * @param tableName The table the metric is for - * @param count Number of occurrences to record - */ - void updateTableReadQueryMeter(TableName tableName, long count); - - /** - * Update table read QPS - * @param tableName The table the metric is for - */ - void updateTableReadQueryMeter(TableName tableName); - - /** - * Update table write QPS - * @param tableName The table the metric is for - * @param count Number of occurrences to record - */ - void updateTableWriteQueryMeter(TableName tableName, long count); - - /** - * Update table write QPS - * @param tableName The table the metric is for - */ - void updateTableWriteQueryMeter(TableName tableName); -} diff --git a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/metrics/impl/GlobalMetricRegistriesAdapter.java b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/metrics/impl/GlobalMetricRegistriesAdapter.java index 9afa094524b7..0d2c44c2e59a 100644 --- a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/metrics/impl/GlobalMetricRegistriesAdapter.java +++ b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/metrics/impl/GlobalMetricRegistriesAdapter.java @@ -115,6 +115,7 @@ private void doRun() { for (MetricRegistry registry : registries) { MetricRegistryInfo info = registry.getMetricRegistryInfo(); + LOG.trace("MetricRegistryInfo : " + info.getMetricsName()); if (info.isExistingSource()) { // If there is an already existing BaseSource for this MetricRegistry, skip it here. These // types of registries are there only due to existing BaseSource implementations in the diff --git a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableLatenciesImpl.java b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableLatenciesImpl.java deleted file mode 100644 index 1c90b33d5d4d..000000000000 --- a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableLatenciesImpl.java +++ /dev/null @@ -1,216 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.hadoop.hbase.regionserver; - -import java.util.HashMap; -import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.metrics.BaseSourceImpl; -import org.apache.hadoop.metrics2.MetricHistogram; -import org.apache.hadoop.metrics2.MetricsCollector; -import org.apache.hadoop.metrics2.MetricsRecordBuilder; -import org.apache.hadoop.metrics2.lib.DynamicMetricsRegistry; -import org.apache.yetus.audience.InterfaceAudience; - -/** - * Implementation of {@link MetricsTableLatencies} to track latencies for one table in a - * RegionServer. - */ -@InterfaceAudience.Private -public class MetricsTableLatenciesImpl extends BaseSourceImpl implements MetricsTableLatencies { - - private final HashMap histogramsByTable = new HashMap<>(); - - public static class TableHistograms { - final MetricHistogram getTimeHisto; - final MetricHistogram incrementTimeHisto; - final MetricHistogram appendTimeHisto; - final MetricHistogram putTimeHisto; - final MetricHistogram putBatchTimeHisto; - final MetricHistogram deleteTimeHisto; - final MetricHistogram deleteBatchTimeHisto; - final MetricHistogram scanTimeHisto; - final MetricHistogram scanSizeHisto; - final MetricHistogram checkAndDeleteTimeHisto; - final MetricHistogram checkAndPutTimeHisto; - final MetricHistogram checkAndMutateTimeHisto; - - TableHistograms(DynamicMetricsRegistry registry, TableName tn) { - getTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, GET_TIME)); - incrementTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, INCREMENT_TIME)); - appendTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, APPEND_TIME)); - putTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, PUT_TIME)); - putBatchTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, PUT_BATCH_TIME)); - deleteTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, DELETE_TIME)); - deleteBatchTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, DELETE_BATCH_TIME)); - scanTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, SCAN_TIME)); - scanSizeHisto = registry.newSizeHistogram(qualifyMetricsName(tn, SCAN_SIZE)); - checkAndDeleteTimeHisto = - registry.newTimeHistogram(qualifyMetricsName(tn, CHECK_AND_DELETE_TIME)); - checkAndPutTimeHisto = registry.newTimeHistogram(qualifyMetricsName(tn, CHECK_AND_PUT_TIME)); - checkAndMutateTimeHisto = - registry.newTimeHistogram(qualifyMetricsName(tn, CHECK_AND_MUTATE_TIME)); - } - - public void updatePut(long time) { - putTimeHisto.add(time); - } - - public void updatePutBatch(long time) { - putBatchTimeHisto.add(time); - } - - public void updateDelete(long t) { - deleteTimeHisto.add(t); - } - - public void updateDeleteBatch(long t) { - deleteBatchTimeHisto.add(t); - } - - public void updateGet(long t) { - getTimeHisto.add(t); - } - - public void updateIncrement(long t) { - incrementTimeHisto.add(t); - } - - public void updateAppend(long t) { - appendTimeHisto.add(t); - } - - public void updateScanSize(long scanSize) { - scanSizeHisto.add(scanSize); - } - - public void updateScanTime(long t) { - scanTimeHisto.add(t); - } - - public void updateCheckAndDeleteTime(long t) { - checkAndDeleteTimeHisto.add(t); - } - - public void updateCheckAndPutTime(long t) { - checkAndPutTimeHisto.add(t); - } - - public void updateCheckAndMutateTime(long t) { - checkAndMutateTimeHisto.add(t); - } - } - - public static String qualifyMetricsName(TableName tableName, String metric) { - StringBuilder sb = new StringBuilder(); - sb.append("Namespace_").append(tableName.getNamespaceAsString()); - sb.append("_table_").append(tableName.getQualifierAsString()); - sb.append("_metric_").append(metric); - return sb.toString(); - } - - public TableHistograms getOrCreateTableHistogram(String tableName) { - // TODO Java8's ConcurrentHashMap#computeIfAbsent would be stellar instead - final TableName tn = TableName.valueOf(tableName); - TableHistograms latency = histogramsByTable.get(tn); - if (latency == null) { - latency = new TableHistograms(getMetricsRegistry(), tn); - histogramsByTable.put(tn, latency); - } - return latency; - } - - public MetricsTableLatenciesImpl() { - this(METRICS_NAME, METRICS_DESCRIPTION, METRICS_CONTEXT, METRICS_JMX_CONTEXT); - } - - public MetricsTableLatenciesImpl(String metricsName, String metricsDescription, - String metricsContext, String metricsJmxContext) { - super(metricsName, metricsDescription, metricsContext, metricsJmxContext); - } - - @Override - public void updatePut(String tableName, long t) { - getOrCreateTableHistogram(tableName).updatePut(t); - } - - @Override - public void updatePutBatch(String tableName, long t) { - getOrCreateTableHistogram(tableName).updatePutBatch(t); - } - - @Override - public void updateDelete(String tableName, long t) { - getOrCreateTableHistogram(tableName).updateDelete(t); - } - - @Override - public void updateDeleteBatch(String tableName, long t) { - getOrCreateTableHistogram(tableName).updateDeleteBatch(t); - } - - @Override - public void updateGet(String tableName, long t) { - getOrCreateTableHistogram(tableName).updateGet(t); - } - - @Override - public void updateIncrement(String tableName, long t) { - getOrCreateTableHistogram(tableName).updateIncrement(t); - } - - @Override - public void updateAppend(String tableName, long t) { - getOrCreateTableHistogram(tableName).updateAppend(t); - } - - @Override - public void updateScanSize(String tableName, long scanSize) { - getOrCreateTableHistogram(tableName).updateScanSize(scanSize); - } - - @Override - public void updateScanTime(String tableName, long t) { - getOrCreateTableHistogram(tableName).updateScanTime(t); - } - - @Override - public void updateCheckAndDelete(String tableName, long time) { - getOrCreateTableHistogram(tableName).updateCheckAndDeleteTime(time); - } - - @Override - public void updateCheckAndPut(String tableName, long time) { - getOrCreateTableHistogram(tableName).updateCheckAndPutTime(time); - } - - @Override - public void updateCheckAndMutate(String tableName, long time) { - getOrCreateTableHistogram(tableName).updateCheckAndMutateTime(time); - } - - @Override - public void getMetrics(MetricsCollector metricsCollector, boolean all) { - MetricsRecordBuilder mrb = metricsCollector.addRecord(metricsName); - // source is registered in supers constructor, sometimes called before the whole initialization. - metricsRegistry.snapshot(mrb, all); - if (metricsAdapter != null) { - // snapshot MetricRegistry as well - metricsAdapter.snapshotAllMetrics(registry, mrb); - } - } -} diff --git a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableQueryMeterImpl.java b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableQueryMeterImpl.java deleted file mode 100644 index dc53c940166d..000000000000 --- a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableQueryMeterImpl.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.hadoop.hbase.regionserver; - -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; -import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.metrics.Meter; -import org.apache.hadoop.hbase.metrics.MetricRegistry; -import org.apache.yetus.audience.InterfaceAudience; - -/** - * Implementation of {@link MetricsTableQueryMeter} to track query per second for each table in a - * RegionServer. - */ -@InterfaceAudience.Private -public class MetricsTableQueryMeterImpl implements MetricsTableQueryMeter { - private final Map metersByTable = new ConcurrentHashMap<>(); - private final MetricRegistry metricRegistry; - - public MetricsTableQueryMeterImpl(MetricRegistry metricRegistry) { - this.metricRegistry = metricRegistry; - } - - private static class TableMeters { - final Meter tableReadQueryMeter; - final Meter tableWriteQueryMeter; - - TableMeters(MetricRegistry metricRegistry, TableName tableName) { - this.tableReadQueryMeter = - metricRegistry.meter(qualifyMetricsName(tableName, TABLE_READ_QUERY_PER_SECOND)); - this.tableWriteQueryMeter = - metricRegistry.meter(qualifyMetricsName(tableName, TABLE_WRITE_QUERY_PER_SECOND)); - } - - public void updateTableReadQueryMeter(long count) { - tableReadQueryMeter.mark(count); - } - - public void updateTableReadQueryMeter() { - tableReadQueryMeter.mark(); - } - - public void updateTableWriteQueryMeter(long count) { - tableWriteQueryMeter.mark(count); - } - - public void updateTableWriteQueryMeter() { - tableWriteQueryMeter.mark(); - } - } - - private static String qualifyMetricsName(TableName tableName, String metric) { - StringBuilder sb = new StringBuilder(); - sb.append("Namespace_").append(tableName.getNamespaceAsString()); - sb.append("_table_").append(tableName.getQualifierAsString()); - sb.append("_metric_").append(metric); - return sb.toString(); - } - - private TableMeters getOrCreateTableMeter(TableName tableName) { - return metersByTable.computeIfAbsent(tableName, tbn -> new TableMeters(metricRegistry, tbn)); - } - - @Override - public void updateTableReadQueryMeter(TableName tableName, long count) { - getOrCreateTableMeter(tableName).updateTableReadQueryMeter(count); - } - - @Override - public void updateTableReadQueryMeter(TableName tableName) { - getOrCreateTableMeter(tableName).updateTableReadQueryMeter(); - } - - @Override - public void updateTableWriteQueryMeter(TableName tableName, long count) { - getOrCreateTableMeter(tableName).updateTableWriteQueryMeter(count); - } - - @Override - public void updateTableWriteQueryMeter(TableName tableName) { - getOrCreateTableMeter(tableName).updateTableWriteQueryMeter(); - } -} diff --git a/hbase-hadoop2-compat/src/main/resources/META-INF/services/org.apache.hadoop.hbase.regionserver.MetricsTableLatencies b/hbase-hadoop2-compat/src/main/resources/META-INF/services/org.apache.hadoop.hbase.regionserver.MetricsTableLatencies deleted file mode 100644 index c0aea2372651..000000000000 --- a/hbase-hadoop2-compat/src/main/resources/META-INF/services/org.apache.hadoop.hbase.regionserver.MetricsTableLatencies +++ /dev/null @@ -1,17 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. -org.apache.hadoop.hbase.regionserver.MetricsTableLatenciesImpl \ No newline at end of file diff --git a/hbase-metrics/src/test/java/org/apache/hadoop/hbase/metrics/impl/TestMetricRegistriesImpl.java b/hbase-metrics/src/test/java/org/apache/hadoop/hbase/metrics/impl/TestMetricRegistriesImpl.java new file mode 100644 index 000000000000..e431ee86ceae --- /dev/null +++ b/hbase-metrics/src/test/java/org/apache/hadoop/hbase/metrics/impl/TestMetricRegistriesImpl.java @@ -0,0 +1,62 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.metrics.impl; + +import static org.junit.Assert.assertTrue; + +import java.util.Optional; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.metrics.MetricRegistries; +import org.apache.hadoop.hbase.metrics.MetricRegistry; +import org.apache.hadoop.hbase.metrics.MetricRegistryInfo; +import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +/** + * Test class for {@link MetricRegistries}. + */ +@Category(SmallTests.class) +public class TestMetricRegistriesImpl { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMetricRegistriesImpl.class); + + @Test + public void testMetricsRegistriesRemoveRef() { + MetricRegistryInfo registryInfo = + new MetricRegistryInfo("testMetrics", null, null, null, false); + MetricRegistries.global().create(registryInfo); + Optional registry1 = MetricRegistries.global().get(registryInfo); + assertTrue(registry1.isPresent()); + + MetricRegistries.global().create(registryInfo); + Optional registry2 = MetricRegistries.global().get(registryInfo); + assertTrue(registry2.isPresent()); + + MetricRegistries.global().remove(registryInfo); + Optional registry3 = MetricRegistries.global().get(registryInfo); + assertTrue(registry3.isPresent()); + + MetricRegistries.global().remove(registryInfo); + Optional registry4 = MetricRegistries.global().get(registryInfo); + assertTrue(!registry4.isPresent()); + } +} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java index cd49b060853f..7edc43f297aa 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java @@ -151,6 +151,7 @@ import org.apache.hadoop.hbase.regionserver.MultiVersionConcurrencyControl.WriteEntry; import org.apache.hadoop.hbase.regionserver.compactions.CompactionContext; import org.apache.hadoop.hbase.regionserver.compactions.CompactionLifeCycleTracker; +import org.apache.hadoop.hbase.regionserver.metrics.MetricsTableRequests; import org.apache.hadoop.hbase.regionserver.throttle.CompactionThroughputControllerFactory; import org.apache.hadoop.hbase.regionserver.throttle.NoLimitThroughputController; import org.apache.hadoop.hbase.regionserver.throttle.StoreHotnessProtector; @@ -367,6 +368,13 @@ public void setRestoredRegion(boolean restoredRegion) { isRestoredRegion = restoredRegion; } + public MetricsTableRequests getMetricsTableRequests() { + return metricsTableRequests; + } + + // Handle table latency metrics + private MetricsTableRequests metricsTableRequests; + // The internal wait duration to acquire a lock before read/update // from the region. It is not per row. The purpose of this wait time // is to avoid waiting a long time while the region is busy, so that @@ -958,6 +966,9 @@ long initialize(final CancelableProgressable reporter) throws IOException { } } + if (metricsTableRequests != null) { + metricsTableRequests.removeRegistry(); + } throw e; } finally { // nextSeqid will be -1 if the initialization fails. @@ -1080,6 +1091,8 @@ private long initializeRegionInternals(final CancelableProgressable reporter, coprocessorHost.postOpen(); } + metricsTableRequests = new MetricsTableRequests(htableDescriptor.getTableName(), conf); + status.markComplete("Region opened successfully"); return nextSeqId; } @@ -1818,6 +1831,13 @@ public Pair> call() throws IOException { } this.closed.set(true); + + // Decrease refCount of table latency metric registry. + // Do this after closed#set to make sure only -1. + if (metricsTableRequests != null) { + metricsTableRequests.removeRegistry(); + } + if (!canFlush) { decrMemStoreSize(this.memStoreSizing.getMemStoreSize()); } else if (this.memStoreSizing.getDataSize() != 0) { @@ -4448,8 +4468,7 @@ private OperationStatus[] batchMutate(BatchOperation batchOp) throws IOExcept } } finally { if (rsServices != null && rsServices.getMetrics() != null) { - rsServices.getMetrics().updateWriteQueryMeter(this.htableDescriptor.getTableName(), - batchOp.size()); + rsServices.getMetrics().updateWriteQueryMeter(this, batchOp.size()); } batchOp.closeRegionOperation(); } @@ -7408,7 +7427,7 @@ void metricsUpdateForGet(List results, long before) { this.metricsRegion.updateGet(EnvironmentEdgeManager.currentTime() - before); } if (rsServices != null && this.rsServices.getMetrics() != null) { - rsServices.getMetrics().updateReadQueryMeter(getTableDescriptor().getTableName(), 1); + rsServices.getMetrics().updateReadQueryMeter(this, 1); } } @@ -7635,8 +7654,7 @@ public void processRowsWithLocks(RowProcessor processor, long timeout, lon releaseRowLocks(acquiredRowLocks); if (rsServices != null && rsServices.getMetrics() != null) { - rsServices.getMetrics().updateWriteQueryMeter(this.htableDescriptor.getTableName(), - mutations.size()); + rsServices.getMetrics().updateWriteQueryMeter(this, mutations.size()); } } success = true; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServer.java index 43009b379ede..a8b38658fd81 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServer.java @@ -19,7 +19,6 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.CompatibilitySingletonFactory; -import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.metrics.Meter; import org.apache.hadoop.hbase.metrics.MetricRegistries; import org.apache.hadoop.hbase.metrics.MetricRegistry; @@ -36,20 +35,13 @@ @InterfaceStability.Evolving @InterfaceAudience.Private public class MetricsRegionServer { - public static final String RS_ENABLE_TABLE_METRICS_KEY = - "hbase.regionserver.enable.table.latencies"; - public static final boolean RS_ENABLE_TABLE_METRICS_DEFAULT = true; public static final String RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY = "hbase.regionserver.enable.server.query.meter"; public static final boolean RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY_DEFAULT = true; - public static final String RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY = - "hbase.regionserver.enable.table.query.meter"; - public static final boolean RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT = true; public static final String SLOW_METRIC_TIME = "hbase.ipc.slow.metric.time"; private final MetricsRegionServerSource serverSource; private final MetricsRegionServerWrapper regionServerWrapper; - private RegionServerTableMetrics tableMetrics; private final MetricsTable metricsTable; private final MetricsUserAggregate userAggregate; private MetricsRegionServerQuotaSource quotaSource; @@ -68,8 +60,7 @@ public MetricsRegionServer(MetricsRegionServerWrapper regionServerWrapper, Confi this(regionServerWrapper, CompatibilitySingletonFactory.getInstance(MetricsRegionServerSourceFactory.class) .createServer(regionServerWrapper), - createTableMetrics(conf), metricsTable, - MetricsUserAggregateFactory.getMetricsUserAggregate(conf)); + metricsTable, MetricsUserAggregateFactory.getMetricsUserAggregate(conf)); // Create hbase-metrics module based metrics. The registry should already be registered by the // MetricsRegionServerSource @@ -90,26 +81,14 @@ public MetricsRegionServer(MetricsRegionServerWrapper regionServerWrapper, Confi } MetricsRegionServer(MetricsRegionServerWrapper regionServerWrapper, - MetricsRegionServerSource serverSource, RegionServerTableMetrics tableMetrics, - MetricsTable metricsTable, MetricsUserAggregate userAggregate) { + MetricsRegionServerSource serverSource, MetricsTable metricsTable, + MetricsUserAggregate userAggregate) { this.regionServerWrapper = regionServerWrapper; this.serverSource = serverSource; - this.tableMetrics = tableMetrics; this.metricsTable = metricsTable; this.userAggregate = userAggregate; } - /** - * Creates an instance of {@link RegionServerTableMetrics} only if the feature is enabled. - */ - static RegionServerTableMetrics createTableMetrics(Configuration conf) { - if (conf.getBoolean(RS_ENABLE_TABLE_METRICS_KEY, RS_ENABLE_TABLE_METRICS_DEFAULT)) { - return new RegionServerTableMetrics(conf.getBoolean(RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY, - RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT)); - } - return null; - } - public MetricsRegionServerSource getMetricsSource() { return serverSource; } @@ -122,16 +101,16 @@ public MetricsRegionServerWrapper getRegionServerWrapper() { return regionServerWrapper; } - public void updatePutBatch(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updatePutBatch(tn, t); + public void updatePutBatch(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updatePutBatch(t); } serverSource.updatePutBatch(t); } - public void updatePut(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updatePut(tn, t); + public void updatePut(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updatePut(t); } if (t > slowMetricTime) { serverSource.incrSlowPut(); @@ -140,9 +119,9 @@ public void updatePut(TableName tn, long t) { userAggregate.updatePut(t); } - public void updateDelete(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateDelete(tn, t); + public void updateDelete(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateDelete(t); } if (t > slowMetricTime) { serverSource.incrSlowDelete(); @@ -151,37 +130,37 @@ public void updateDelete(TableName tn, long t) { userAggregate.updateDelete(t); } - public void updateDeleteBatch(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateDeleteBatch(tn, t); + public void updateDeleteBatch(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateDeleteBatch(t); } serverSource.updateDeleteBatch(t); } - public void updateCheckAndDelete(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateCheckAndDelete(tn, t); + public void updateCheckAndDelete(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateCheckAndDelete(t); } serverSource.updateCheckAndDelete(t); } - public void updateCheckAndPut(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateCheckAndPut(tn, t); + public void updateCheckAndPut(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateCheckAndPut(t); } serverSource.updateCheckAndPut(t); } - public void updateCheckAndMutate(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateCheckAndMutate(tn, t); + public void updateCheckAndMutate(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateCheckAndMutate(t); } serverSource.updateCheckAndMutate(t); } - public void updateGet(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateGet(tn, t); + public void updateGet(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateGet(t); } if (t > slowMetricTime) { serverSource.incrSlowGet(); @@ -190,9 +169,9 @@ public void updateGet(TableName tn, long t) { userAggregate.updateGet(t); } - public void updateIncrement(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateIncrement(tn, t); + public void updateIncrement(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateIncrement(t); } if (t > slowMetricTime) { serverSource.incrSlowIncrement(); @@ -201,9 +180,9 @@ public void updateIncrement(TableName tn, long t) { userAggregate.updateIncrement(t); } - public void updateAppend(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateAppend(tn, t); + public void updateAppend(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateAppend(t); } if (t > slowMetricTime) { serverSource.incrSlowAppend(); @@ -217,16 +196,16 @@ public void updateReplay(long t) { userAggregate.updateReplay(t); } - public void updateScanSize(TableName tn, long scanSize) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateScanSize(tn, scanSize); + public void updateScanSize(HRegion region, long scanSize) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateScanSize(scanSize); } serverSource.updateScanSize(scanSize); } - public void updateScanTime(TableName tn, long t) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateScanTime(tn, t); + public void updateScanTime(HRegion region, long t) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateScanTime(t); } serverSource.updateScanTime(t); userAggregate.updateScanTime(t); @@ -278,27 +257,27 @@ public void updateBulkLoad(long millis) { this.bulkLoadTimer.updateMillis(millis); } - public void updateReadQueryMeter(TableName tn, long count) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateTableReadQueryMeter(tn, count); + public void updateReadQueryMeter(HRegion region, long count) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateTableReadQueryMeter(count); } if (serverReadQueryMeter != null) { serverReadQueryMeter.mark(count); } } - public void updateWriteQueryMeter(TableName tn, long count) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateTableWriteQueryMeter(tn, count); + public void updateWriteQueryMeter(HRegion region, long count) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateTableWriteQueryMeter(count); } if (serverWriteQueryMeter != null) { serverWriteQueryMeter.mark(count); } } - public void updateWriteQueryMeter(TableName tn) { - if (tableMetrics != null && tn != null) { - tableMetrics.updateTableWriteQueryMeter(tn); + public void updateWriteQueryMeter(HRegion region) { + if (region.getMetricsTableRequests() != null) { + region.getMetricsTableRequests().updateTableWriteQueryMeter(); } if (serverWriteQueryMeter != null) { serverWriteQueryMeter.mark(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java index 3e9da1420bbe..981c8efb9cd2 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java @@ -716,8 +716,7 @@ private Result append(final HRegion region, final OperationQuota quota, long nonce = mutation.hasNonce() ? mutation.getNonce() : HConstants.NO_NONCE; Result r = region.append(append, nonceGroup, nonce); if (regionServer.getMetrics() != null) { - regionServer.getMetrics().updateAppend(region.getTableDescriptor().getTableName(), - EnvironmentEdgeManager.currentTime() - before); + regionServer.getMetrics().updateAppend(region, EnvironmentEdgeManager.currentTime() - before); } return r == null ? Result.EMPTY_RESULT : r; } @@ -737,8 +736,7 @@ private Result increment(final HRegion region, final OperationQuota quota, Result r = region.increment(increment, nonceGroup, nonce); final MetricsRegionServer metricsRegionServer = regionServer.getMetrics(); if (metricsRegionServer != null) { - metricsRegionServer.updateIncrement(region.getTableDescriptor().getTableName(), - EnvironmentEdgeManager.currentTime() - before); + metricsRegionServer.updateIncrement(region, EnvironmentEdgeManager.currentTime() - before); } return r == null ? Result.EMPTY_RESULT : r; } @@ -830,8 +828,7 @@ private List doNonAtomicRegionMutation(final HRegion region, } finally { final MetricsRegionServer metricsRegionServer = regionServer.getMetrics(); if (metricsRegionServer != null) { - metricsRegionServer.updateGet(region.getTableDescriptor().getTableName(), - EnvironmentEdgeManager.currentTime() - before); + metricsRegionServer.updateGet(region, EnvironmentEdgeManager.currentTime() - before); } } } else if (action.hasServiceCall()) { @@ -1120,12 +1117,10 @@ private void updateMutationMetrics(HRegion region, long starttime, boolean batch if (metricsRegionServer != null) { long after = EnvironmentEdgeManager.currentTime(); if (batchContainsPuts) { - metricsRegionServer.updatePutBatch(region.getTableDescriptor().getTableName(), - after - starttime); + metricsRegionServer.updatePutBatch(region, after - starttime); } if (batchContainsDelete) { - metricsRegionServer.updateDeleteBatch(region.getTableDescriptor().getTableName(), - after - starttime); + metricsRegionServer.updateDeleteBatch(region, after - starttime); } } } @@ -2590,8 +2585,7 @@ public GetResponse get(final RpcController controller, final GetRequest request) if (metricsRegionServer != null) { TableDescriptor td = region != null ? region.getTableDescriptor() : null; if (td != null) { - metricsRegionServer.updateGet(td.getTableName(), - EnvironmentEdgeManager.currentTime() - before); + metricsRegionServer.updateGet(region, EnvironmentEdgeManager.currentTime() - before); } } if (quota != null) { @@ -3017,7 +3011,7 @@ private void put(HRegion region, OperationQuota quota, MutationProto mutation, MetricsRegionServer metricsRegionServer = regionServer.getMetrics(); if (metricsRegionServer != null) { long after = EnvironmentEdgeManager.currentTime(); - metricsRegionServer.updatePut(region.getRegionInfo().getTable(), after - before); + metricsRegionServer.updatePut(region, after - before); } } @@ -3033,7 +3027,7 @@ private void delete(HRegion region, OperationQuota quota, MutationProto mutation MetricsRegionServer metricsRegionServer = regionServer.getMetrics(); if (metricsRegionServer != null) { long after = EnvironmentEdgeManager.currentTime(); - metricsRegionServer.updateDelete(region.getRegionInfo().getTable(), after - before); + metricsRegionServer.updateDelete(region, after - before); } } @@ -3060,16 +3054,15 @@ private CheckAndMutateResult checkAndMutate(HRegion region, OperationQuota quota MetricsRegionServer metricsRegionServer = regionServer.getMetrics(); if (metricsRegionServer != null) { long after = EnvironmentEdgeManager.currentTime(); - metricsRegionServer.updateCheckAndMutate(region.getRegionInfo().getTable(), after - before); + metricsRegionServer.updateCheckAndMutate(region, after - before); MutationType type = mutation.getMutateType(); switch (type) { case PUT: - metricsRegionServer.updateCheckAndPut(region.getRegionInfo().getTable(), after - before); + metricsRegionServer.updateCheckAndPut(region, after - before); break; case DELETE: - metricsRegionServer.updateCheckAndDelete(region.getRegionInfo().getTable(), - after - before); + metricsRegionServer.updateCheckAndDelete(region, after - before); break; default: break; @@ -3489,12 +3482,9 @@ private void scan(HBaseRpcController controller, ScanRequest request, RegionScan region.getMetrics().updateScanTime(end - before); final MetricsRegionServer metricsRegionServer = regionServer.getMetrics(); if (metricsRegionServer != null) { - metricsRegionServer.updateScanSize(region.getTableDescriptor().getTableName(), - responseCellSize); - metricsRegionServer.updateScanTime(region.getTableDescriptor().getTableName(), - end - before); - metricsRegionServer.updateReadQueryMeter(region.getRegionInfo().getTable(), - numOfNextRawCalls); + metricsRegionServer.updateScanSize(region, responseCellSize); + metricsRegionServer.updateScanTime(region, end - before); + metricsRegionServer.updateReadQueryMeter(region, numOfNextRawCalls); } } // coprocessor postNext hook diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerTableMetrics.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerTableMetrics.java deleted file mode 100644 index efc103b8bca7..000000000000 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerTableMetrics.java +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.hadoop.hbase.regionserver; - -import org.apache.hadoop.hbase.CompatibilitySingletonFactory; -import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.metrics.MetricRegistries; -import org.apache.yetus.audience.InterfaceAudience; - -/** - * Captures operation metrics by table. Separates metrics collection for table metrics away from - * {@link MetricsRegionServer} for encapsulation and ease of testing. - */ -@InterfaceAudience.Private -public class RegionServerTableMetrics { - - private final MetricsTableLatencies latencies; - private MetricsTableQueryMeter queryMeter; - - public RegionServerTableMetrics(boolean enableTableQueryMeter) { - latencies = CompatibilitySingletonFactory.getInstance(MetricsTableLatencies.class); - if (enableTableQueryMeter) { - queryMeter = new MetricsTableQueryMeterImpl(MetricRegistries.global() - .get(((MetricsTableLatenciesImpl) latencies).getMetricRegistryInfo()).get()); - } - } - - public void updatePut(TableName table, long time) { - latencies.updatePut(table.getNameAsString(), time); - } - - public void updatePutBatch(TableName table, long time) { - latencies.updatePutBatch(table.getNameAsString(), time); - } - - public void updateGet(TableName table, long time) { - latencies.updateGet(table.getNameAsString(), time); - } - - public void updateIncrement(TableName table, long time) { - latencies.updateIncrement(table.getNameAsString(), time); - } - - public void updateAppend(TableName table, long time) { - latencies.updateAppend(table.getNameAsString(), time); - } - - public void updateDelete(TableName table, long time) { - latencies.updateDelete(table.getNameAsString(), time); - } - - public void updateDeleteBatch(TableName table, long time) { - latencies.updateDeleteBatch(table.getNameAsString(), time); - } - - public void updateCheckAndDelete(TableName table, long time) { - latencies.updateCheckAndDelete(table.getNameAsString(), time); - } - - public void updateCheckAndPut(TableName table, long time) { - latencies.updateCheckAndPut(table.getNameAsString(), time); - } - - public void updateCheckAndMutate(TableName table, long time) { - latencies.updateCheckAndMutate(table.getNameAsString(), time); - } - - public void updateScanTime(TableName table, long time) { - latencies.updateScanTime(table.getNameAsString(), time); - } - - public void updateScanSize(TableName table, long size) { - latencies.updateScanSize(table.getNameAsString(), size); - } - - public void updateTableReadQueryMeter(TableName table, long count) { - if (queryMeter != null) { - queryMeter.updateTableReadQueryMeter(table, count); - } - } - - public void updateTableWriteQueryMeter(TableName table, long count) { - if (queryMeter != null) { - queryMeter.updateTableWriteQueryMeter(table, count); - } - } - - public void updateTableWriteQueryMeter(TableName table) { - if (queryMeter != null) { - queryMeter.updateTableWriteQueryMeter(table); - } - } -} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/metrics/MetricsTableRequests.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/metrics/MetricsTableRequests.java new file mode 100644 index 000000000000..977818f1fd86 --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/metrics/MetricsTableRequests.java @@ -0,0 +1,331 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.regionserver.metrics; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.metrics.Histogram; +import org.apache.hadoop.hbase.metrics.Meter; +import org.apache.hadoop.hbase.metrics.MetricRegistries; +import org.apache.hadoop.hbase.metrics.MetricRegistry; +import org.apache.hadoop.hbase.metrics.MetricRegistryInfo; +import org.apache.yetus.audience.InterfaceAudience; + +@InterfaceAudience.Private +public class MetricsTableRequests { + + public static final String ENABLE_TABLE_LATENCIES_METRICS_KEY = + "hbase.regionserver.enable.table.latencies"; + + public static final boolean ENABLE_TABLE_LATENCIES_METRICS_DEFAULT = true; + + public static final String ENABLE_TABLE_QUERY_METER_METRICS_KEY = + "hbase.regionserver.enable.table.query.meter"; + + public static final boolean ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT = true; + + /** + * The name of the metrics + */ + private final static String METRICS_NAME = "TableRequests"; + + /** + * The name of the metrics context that metrics will be under. + */ + private final static String METRICS_CONTEXT = "regionserver"; + + /** + * Description + */ + private final static String METRICS_DESCRIPTION = + "Metrics about Tables on a single HBase RegionServer"; + + /** + * The name of the metrics context that metrics will be under in jmx + */ + private final static String METRICS_JMX_CONTEXT = "RegionServer,sub=" + METRICS_NAME; + + private final static String GET_TIME = "getTime"; + private final static String SCAN_TIME = "scanTime"; + private final static String SCAN_SIZE = "scanSize"; + private final static String PUT_TIME = "putTime"; + private final static String PUT_BATCH_TIME = "putBatchTime"; + private final static String DELETE_TIME = "deleteTime"; + private final static String DELETE_BATCH_TIME = "deleteBatchTime"; + private final static String INCREMENT_TIME = "incrementTime"; + private final static String APPEND_TIME = "appendTime"; + private final static String CHECK_AND_DELETE_TIME = "checkAndDeleteTime"; + private final static String CHECK_AND_PUT_TIME = "checkAndPutTime"; + private final static String CHECK_AND_MUTATE_TIME = "checkAndMutateTime"; + private final static String TABLE_READ_QUERY_PER_SECOND = "tableReadQueryPerSecond"; + private final static String TABLE_WRITE_QUERY_PER_SECOND = "tableWriteQueryPerSecond"; + + private Histogram getTimeHistogram; + private Histogram scanTimeHistogram; + private Histogram scanSizeHistogram; + private Histogram putTimeHistogram; + private Histogram putBatchTimeHistogram; + private Histogram deleteTimeHistogram; + private Histogram deleteBatchTimeHistogram; + private Histogram incrementTimeHistogram; + private Histogram appendTimeHistogram; + private Histogram checkAndDeleteTimeHistogram; + private Histogram checkAndPutTimeHistogram; + private Histogram checkAndMutateTimeHistogram; + + private Meter readMeter; + private Meter writeMeter; + + private MetricRegistry registry; + private TableName tableName; + private Configuration conf; + private MetricRegistryInfo registryInfo; + + private boolean enableTableLatenciesMetrics; + private boolean enabTableQueryMeterMetrics; + + public boolean isEnableTableLatenciesMetrics() { + return enableTableLatenciesMetrics; + } + + public boolean isEnabTableQueryMeterMetrics() { + return enabTableQueryMeterMetrics; + } + + public MetricsTableRequests(TableName tableName, Configuration conf) { + init(tableName, conf); + } + + private void init(TableName tableName, Configuration conf) { + this.tableName = tableName; + this.conf = conf; + enableTableLatenciesMetrics = this.conf.getBoolean(ENABLE_TABLE_LATENCIES_METRICS_KEY, + ENABLE_TABLE_LATENCIES_METRICS_DEFAULT); + enabTableQueryMeterMetrics = this.conf.getBoolean(ENABLE_TABLE_QUERY_METER_METRICS_KEY, + ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT); + if (enableTableLatenciesMetrics || enabTableQueryMeterMetrics) { + registry = createRegistryForTableRequests(); + if (enableTableLatenciesMetrics) { + getTimeHistogram = registry.histogram(GET_TIME); + scanTimeHistogram = registry.histogram(SCAN_TIME); + scanSizeHistogram = registry.histogram(SCAN_SIZE); + putTimeHistogram = registry.histogram(PUT_TIME); + putBatchTimeHistogram = registry.histogram(PUT_BATCH_TIME); + deleteTimeHistogram = registry.histogram(DELETE_TIME); + deleteBatchTimeHistogram = registry.histogram(DELETE_BATCH_TIME); + incrementTimeHistogram = registry.histogram(INCREMENT_TIME); + appendTimeHistogram = registry.histogram(APPEND_TIME); + checkAndDeleteTimeHistogram = registry.histogram(CHECK_AND_DELETE_TIME); + checkAndPutTimeHistogram = registry.histogram(CHECK_AND_PUT_TIME); + checkAndMutateTimeHistogram = registry.histogram(CHECK_AND_MUTATE_TIME); + } + + if (enabTableQueryMeterMetrics) { + readMeter = registry.meter(TABLE_READ_QUERY_PER_SECOND); + writeMeter = registry.meter(TABLE_WRITE_QUERY_PER_SECOND); + } + } + } + + private MetricRegistry createRegistryForTableRequests() { + return MetricRegistries.global().create(createRegistryInfoForTableRequests()); + } + + private MetricRegistryInfo createRegistryInfoForTableRequests() { + registryInfo = new MetricRegistryInfo(qualifyMetrics(METRICS_NAME, tableName), + METRICS_DESCRIPTION, qualifyMetrics(METRICS_JMX_CONTEXT, tableName), METRICS_CONTEXT, false); + return registryInfo; + } + + public void removeRegistry() { + if (enableTableLatenciesMetrics || enabTableQueryMeterMetrics) { + MetricRegistries.global().remove(registry.getMetricRegistryInfo()); + } + } + + private static String qualifyMetrics(String prefix, TableName tableName) { + StringBuilder sb = new StringBuilder(); + sb.append(prefix).append("_"); + sb.append("Namespace_").append(tableName.getNamespaceAsString()); + sb.append("_table_").append(tableName.getQualifierAsString()); + return sb.toString(); + } + + /** + * Update the Put time histogram + * @param t time it took + */ + public void updatePut(long t) { + if (isEnableTableLatenciesMetrics()) { + putTimeHistogram.update(t); + } + } + + /** + * Update the batch Put time histogram + * @param t time it took + */ + public void updatePutBatch(long t) { + if (isEnableTableLatenciesMetrics()) { + putBatchTimeHistogram.update(t); + } + } + + /** + * Update the Delete time histogram + * @param t time it took + */ + public void updateDelete(long t) { + if (isEnableTableLatenciesMetrics()) { + deleteTimeHistogram.update(t); + } + } + + /** + * Update the batch Delete time histogram + * @param t time it took + */ + public void updateDeleteBatch(long t) { + if (isEnableTableLatenciesMetrics()) { + deleteBatchTimeHistogram.update(t); + } + } + + /** + * Update the Get time histogram . + * @param t time it took + */ + public void updateGet(long t) { + if (isEnableTableLatenciesMetrics()) { + getTimeHistogram.update(t); + } + } + + /** + * Update the Increment time histogram. + * @param t time it took + */ + public void updateIncrement(long t) { + if (isEnableTableLatenciesMetrics()) { + incrementTimeHistogram.update(t); + } + } + + /** + * Update the Append time histogram. + * @param t time it took + */ + public void updateAppend(long t) { + if (isEnableTableLatenciesMetrics()) { + appendTimeHistogram.update(t); + } + } + + /** + * Update the scan size. + * @param scanSize size of the scan + */ + public void updateScanSize(long scanSize) { + if (isEnableTableLatenciesMetrics()) { + scanSizeHistogram.update(scanSize); + } + } + + /** + * Update the scan time. + * @param t time it took + */ + public void updateScanTime(long t) { + if (isEnableTableLatenciesMetrics()) { + scanTimeHistogram.update(t); + } + } + + /** + * Update the CheckAndDelete time histogram. + * @param time time it took + */ + public void updateCheckAndDelete(long time) { + if (isEnableTableLatenciesMetrics()) { + checkAndDeleteTimeHistogram.update(time); + } + } + + /** + * Update the CheckAndPut time histogram. + * @param time time it took + */ + public void updateCheckAndPut(long time) { + if (isEnableTableLatenciesMetrics()) { + checkAndPutTimeHistogram.update(time); + } + } + + /** + * Update the CheckAndMutate time histogram. + * @param time time it took + */ + public void updateCheckAndMutate(long time) { + if (isEnableTableLatenciesMetrics()) { + checkAndMutateTimeHistogram.update(time); + } + } + + /** + * Update table read QPS + * @param count Number of occurrences to record + */ + public void updateTableReadQueryMeter(long count) { + if (isEnabTableQueryMeterMetrics()) { + readMeter.mark(count); + } + } + + /** + * Update table read QPS + */ + public void updateTableReadQueryMeter() { + if (isEnabTableQueryMeterMetrics()) { + readMeter.mark(); + } + } + + /** + * Update table write QPS + * @param count Number of occurrences to record + */ + public void updateTableWriteQueryMeter(long count) { + if (isEnabTableQueryMeterMetrics()) { + writeMeter.mark(count); + } + } + + /** + * Update table write QPS + */ + public void updateTableWriteQueryMeter() { + if (isEnabTableQueryMeterMetrics()) { + writeMeter.mark(); + } + } + + // Visible for testing + public MetricRegistryInfo getMetricRegistryInfo() { + return registryInfo; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsRegionServer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsRegionServer.java index 891ae2805114..095c0a155ba8 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsRegionServer.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsRegionServer.java @@ -20,11 +20,13 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.CompatibilityFactory; import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.regionserver.metrics.MetricsTableRequests; import org.apache.hadoop.hbase.test.MetricsAssertHelper; import org.apache.hadoop.hbase.testclassification.RegionServerTests; import org.apache.hadoop.hbase.testclassification.SmallTests; @@ -146,35 +148,40 @@ public void testConstuctor() { @Test public void testSlowCount() { + HRegion region = mock(HRegion.class); + MetricsTableRequests metricsTableRequests = mock(MetricsTableRequests.class); + when(region.getMetricsTableRequests()).thenReturn(metricsTableRequests); + when(metricsTableRequests.isEnableTableLatenciesMetrics()).thenReturn(false); + when(metricsTableRequests.isEnabTableQueryMeterMetrics()).thenReturn(false); for (int i = 0; i < 12; i++) { - rsm.updateAppend(null, 12); - rsm.updateAppend(null, 1002); + rsm.updateAppend(region, 12); + rsm.updateAppend(region, 1002); } for (int i = 0; i < 13; i++) { - rsm.updateDeleteBatch(null, 13); - rsm.updateDeleteBatch(null, 1003); + rsm.updateDeleteBatch(region, 13); + rsm.updateDeleteBatch(region, 1003); } for (int i = 0; i < 14; i++) { - rsm.updateGet(null, 14); - rsm.updateGet(null, 1004); + rsm.updateGet(region, 14); + rsm.updateGet(region, 1004); } for (int i = 0; i < 15; i++) { - rsm.updateIncrement(null, 15); - rsm.updateIncrement(null, 1005); + rsm.updateIncrement(region, 15); + rsm.updateIncrement(region, 1005); } for (int i = 0; i < 16; i++) { - rsm.updatePutBatch(null, 16); - rsm.updatePutBatch(null, 1006); + rsm.updatePutBatch(region, 16); + rsm.updatePutBatch(region, 1006); } for (int i = 0; i < 17; i++) { - rsm.updatePut(null, 17); - rsm.updateDelete(null, 17); - rsm.updatePut(null, 1006); - rsm.updateDelete(null, 1003); - rsm.updateCheckAndDelete(null, 17); - rsm.updateCheckAndPut(null, 17); - rsm.updateCheckAndMutate(null, 17); + rsm.updatePut(region, 17); + rsm.updateDelete(region, 17); + rsm.updatePut(region, 1006); + rsm.updateDelete(region, 1003); + rsm.updateCheckAndDelete(region, 17); + rsm.updateCheckAndPut(region, 17); + rsm.updateCheckAndMutate(region, 17); } HELPER.assertCounter("appendNumOps", 24, serverSource); @@ -268,11 +275,15 @@ public void testPauseMonitor() { @Test public void testTableQueryMeterSwitch() { - TableName tn1 = TableName.valueOf("table1"); + HRegion region = mock(HRegion.class); + MetricsTableRequests metricsTableRequests = mock(MetricsTableRequests.class); + when(region.getMetricsTableRequests()).thenReturn(metricsTableRequests); + when(metricsTableRequests.isEnableTableLatenciesMetrics()).thenReturn(false); + when(metricsTableRequests.isEnabTableQueryMeterMetrics()).thenReturn(false); // has been set disable in setUp() - rsm.updateReadQueryMeter(tn1, 500L); + rsm.updateReadQueryMeter(region, 500L); assertFalse(HELPER.checkGaugeExists("ServerReadQueryPerSecond_count", serverSource)); - rsm.updateWriteQueryMeter(tn1, 500L); + rsm.updateWriteQueryMeter(region, 500L); assertFalse(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); // enable @@ -280,11 +291,11 @@ public void testTableQueryMeterSwitch() { conf.setBoolean(MetricsRegionServer.RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY, true); rsm = new MetricsRegionServer(wrapper, conf, null); serverSource = rsm.getMetricsSource(); - rsm.updateReadQueryMeter(tn1, 500L); + rsm.updateReadQueryMeter(region, 500L); assertTrue(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); HELPER.assertGauge("ServerReadQueryPerSecond_count", 500L, serverSource); assertTrue(HELPER.checkGaugeExists("ServerWriteQueryPerSecond_count", serverSource)); - rsm.updateWriteQueryMeter(tn1, 500L); + rsm.updateWriteQueryMeter(region, 500L); HELPER.assertGauge("ServerWriteQueryPerSecond_count", 500L, serverSource); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsTableLatencies.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsTableLatencies.java deleted file mode 100644 index 68d12d3149e9..000000000000 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsTableLatencies.java +++ /dev/null @@ -1,123 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.hadoop.hbase.regionserver; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import java.io.IOException; -import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.CompatibilityFactory; -import org.apache.hadoop.hbase.CompatibilitySingletonFactory; -import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.test.MetricsAssertHelper; -import org.apache.hadoop.hbase.testclassification.RegionServerTests; -import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; - -@Category({ RegionServerTests.class, SmallTests.class }) -public class TestMetricsTableLatencies { - - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestMetricsTableLatencies.class); - - public static MetricsAssertHelper HELPER = - CompatibilityFactory.getInstance(MetricsAssertHelper.class); - - @Test - public void testTableWrapperAggregateMetrics() throws IOException { - TableName tn1 = TableName.valueOf("table1"); - TableName tn2 = TableName.valueOf("table2"); - MetricsTableLatencies latencies = - CompatibilitySingletonFactory.getInstance(MetricsTableLatencies.class); - assertTrue("'latencies' is actually " + latencies.getClass(), - latencies instanceof MetricsTableLatenciesImpl); - MetricsTableLatenciesImpl latenciesImpl = (MetricsTableLatenciesImpl) latencies; - RegionServerTableMetrics tableMetrics = new RegionServerTableMetrics(false); - - // Metrics to each table should be disjoint - // N.B. each call to assertGauge removes all previously acquired metrics so we have to - // make the metrics call and then immediately verify it. Trying to do multiple metrics - // updates followed by multiple verifications will fail on the 2nd verification (as the - // first verification cleaned the data structures in MetricsAssertHelperImpl). - tableMetrics.updateGet(tn1, 500L); - HELPER.assertGauge(MetricsTableLatenciesImpl.qualifyMetricsName(tn1, - MetricsTableLatencies.GET_TIME + "_" + "999th_percentile"), 500L, latenciesImpl); - tableMetrics.updatePut(tn1, 50L); - HELPER.assertGauge(MetricsTableLatenciesImpl.qualifyMetricsName(tn1, - MetricsTableLatencies.PUT_TIME + "_" + "99th_percentile"), 50L, latenciesImpl); - - tableMetrics.updateGet(tn2, 300L); - HELPER.assertGauge(MetricsTableLatenciesImpl.qualifyMetricsName(tn2, - MetricsTableLatencies.GET_TIME + "_" + "999th_percentile"), 300L, latenciesImpl); - tableMetrics.updatePut(tn2, 75L); - HELPER.assertGauge(MetricsTableLatenciesImpl.qualifyMetricsName(tn2, - MetricsTableLatencies.PUT_TIME + "_" + "99th_percentile"), 75L, latenciesImpl); - } - - @Test - public void testTableQueryMeterSwitch() { - TableName tn1 = TableName.valueOf("table1"); - MetricsTableLatencies latencies = - CompatibilitySingletonFactory.getInstance(MetricsTableLatencies.class); - assertTrue("'latencies' is actually " + latencies.getClass(), - latencies instanceof MetricsTableLatenciesImpl); - MetricsTableLatenciesImpl latenciesImpl = (MetricsTableLatenciesImpl) latencies; - - Configuration conf = new Configuration(); - conf.setBoolean(MetricsRegionServer.RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY, false); - boolean enableTableQueryMeter = - conf.getBoolean(MetricsRegionServer.RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY, - MetricsRegionServer.RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT); - // disable - assertFalse(enableTableQueryMeter); - RegionServerTableMetrics tableMetrics = new RegionServerTableMetrics(enableTableQueryMeter); - tableMetrics.updateTableReadQueryMeter(tn1, 500L); - assertFalse(HELPER.checkGaugeExists(MetricsTableLatenciesImpl.qualifyMetricsName(tn1, - MetricsTableQueryMeterImpl.TABLE_READ_QUERY_PER_SECOND + "_" + "count"), latenciesImpl)); - tableMetrics.updateTableWriteQueryMeter(tn1, 500L); - assertFalse(HELPER.checkGaugeExists(MetricsTableLatenciesImpl.qualifyMetricsName(tn1, - MetricsTableQueryMeterImpl.TABLE_WRITE_QUERY_PER_SECOND + "_" + "count"), latenciesImpl)); - - // enable - conf.setBoolean(MetricsRegionServer.RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY, true); - enableTableQueryMeter = - conf.getBoolean(MetricsRegionServer.RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY, - MetricsRegionServer.RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT); - assertTrue(enableTableQueryMeter); - tableMetrics = new RegionServerTableMetrics(true); - tableMetrics.updateTableReadQueryMeter(tn1, 500L); - assertTrue(HELPER.checkGaugeExists(MetricsTableLatenciesImpl.qualifyMetricsName(tn1, - MetricsTableQueryMeterImpl.TABLE_READ_QUERY_PER_SECOND + "_" + "count"), latenciesImpl)); - HELPER.assertGauge( - MetricsTableLatenciesImpl.qualifyMetricsName(tn1, - MetricsTableQueryMeterImpl.TABLE_READ_QUERY_PER_SECOND + "_" + "count"), - 500L, latenciesImpl); - tableMetrics.updateTableWriteQueryMeter(tn1, 500L); - assertTrue(HELPER.checkGaugeExists(MetricsTableLatenciesImpl.qualifyMetricsName(tn1, - MetricsTableQueryMeterImpl.TABLE_WRITE_QUERY_PER_SECOND + "_" + "count"), latenciesImpl)); - HELPER.assertGauge( - MetricsTableLatenciesImpl.qualifyMetricsName(tn1, - MetricsTableQueryMeterImpl.TABLE_WRITE_QUERY_PER_SECOND + "_" + "count"), - 500L, latenciesImpl); - } -} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsTableRequests.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsTableRequests.java new file mode 100644 index 000000000000..40c910190749 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsTableRequests.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.regionserver; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.util.Optional; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.metrics.Metric; +import org.apache.hadoop.hbase.metrics.MetricRegistries; +import org.apache.hadoop.hbase.metrics.MetricRegistry; +import org.apache.hadoop.hbase.metrics.MetricRegistryInfo; +import org.apache.hadoop.hbase.metrics.Snapshot; +import org.apache.hadoop.hbase.metrics.impl.DropwizardMeter; +import org.apache.hadoop.hbase.metrics.impl.HistogramImpl; +import org.apache.hadoop.hbase.regionserver.metrics.MetricsTableRequests; +import org.apache.hadoop.hbase.testclassification.RegionServerTests; +import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +@Category({ RegionServerTests.class, SmallTests.class }) +public class TestMetricsTableRequests { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMetricsTableRequests.class); + + @Test + public void testMetricsTableLatencies() { + TableName tn1 = TableName.valueOf("table1"); + TableName tn2 = TableName.valueOf("table2"); + MetricsTableRequests requests1 = new MetricsTableRequests(tn1, new Configuration()); + MetricsTableRequests requests2 = new MetricsTableRequests(tn2, new Configuration()); + assertTrue("'requests' is actually " + requests1.getClass(), + requests1 instanceof MetricsTableRequests); + assertTrue("'requests' is actually " + requests2.getClass(), + requests2 instanceof MetricsTableRequests); + + MetricRegistryInfo info1 = requests1.getMetricRegistryInfo(); + MetricRegistryInfo info2 = requests2.getMetricRegistryInfo(); + Optional registry1 = MetricRegistries.global().get(info1); + assertTrue(registry1.isPresent()); + Optional registry2 = MetricRegistries.global().get(info2); + assertTrue(registry2.isPresent()); + + requests1.updateGet(500L); + Snapshot latencies1SnapshotGet = + ((HistogramImpl) registry1.get().get("getTime").get()).snapshot(); + assertEquals(500, latencies1SnapshotGet.get999thPercentile()); + + requests1.updatePut(50L); + Snapshot latencies1SnapshotPut = + ((HistogramImpl) registry1.get().get("putTime").get()).snapshot(); + assertEquals(50, latencies1SnapshotPut.get99thPercentile()); + + requests2.updateGet(300L); + Snapshot latencies2SnapshotGet = + ((HistogramImpl) registry2.get().get("getTime").get()).snapshot(); + assertEquals(300, latencies2SnapshotGet.get999thPercentile()); + + requests2.updatePut(75L); + Snapshot latencies2SnapshotPut = + ((HistogramImpl) registry2.get().get("putTime").get()).snapshot(); + assertEquals(75, latencies2SnapshotPut.get99thPercentile()); + } + + @Test + public void testTableQueryMeterSwitch() { + TableName tn1 = TableName.valueOf("table1"); + Configuration conf = new Configuration(); + boolean enableTableQueryMeter = + conf.getBoolean(MetricsTableRequests.ENABLE_TABLE_QUERY_METER_METRICS_KEY, + MetricsTableRequests.ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT); + // enable + assertTrue(enableTableQueryMeter); + MetricsTableRequests requests = new MetricsTableRequests(tn1, conf); + assertTrue("'requests' is actually " + requests.getClass(), + requests instanceof MetricsTableRequests); + + MetricRegistryInfo info = requests.getMetricRegistryInfo(); + Optional registry = MetricRegistries.global().get(info); + assertTrue(registry.isPresent()); + requests.updateTableReadQueryMeter(500L); + Optional read = registry.get().get("tableReadQueryPerSecond"); + assertTrue(read.isPresent()); + assertEquals(((DropwizardMeter) read.get()).getCount(), 500); + + // disable + conf.setBoolean(MetricsTableRequests.ENABLE_TABLE_QUERY_METER_METRICS_KEY, false); + enableTableQueryMeter = + conf.getBoolean(MetricsTableRequests.ENABLE_TABLE_QUERY_METER_METRICS_KEY, + MetricsTableRequests.ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT); + assertTrue(enableTableQueryMeter); + requests = new MetricsTableRequests(tn1, conf); + assertTrue("'requests' is actually " + requests.getClass(), + requests instanceof MetricsTableRequests); + + info = requests.getMetricRegistryInfo(); + registry = MetricRegistries.global().get(info); + assertTrue(registry.isPresent()); + requests.updateTableReadQueryMeter(500L); + read = registry.get().get("tableReadQueryPerSecond"); + assertFalse(read.isPresent()); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsUserAggregate.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsUserAggregate.java index 3abd6ceb0390..abb11ee18738 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsUserAggregate.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMetricsUserAggregate.java @@ -19,6 +19,8 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; import java.security.PrivilegedAction; import org.apache.hadoop.conf.Configuration; @@ -26,6 +28,7 @@ import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.regionserver.metrics.MetricsTableRequests; import org.apache.hadoop.hbase.security.User; import org.apache.hadoop.hbase.test.MetricsAssertHelper; import org.apache.hadoop.hbase.testclassification.LargeTests; @@ -65,23 +68,28 @@ public void setUp() { } private void doOperations() { + HRegion region = mock(HRegion.class); + MetricsTableRequests metricsTableRequests = mock(MetricsTableRequests.class); + when(region.getMetricsTableRequests()).thenReturn(metricsTableRequests); + when(metricsTableRequests.isEnableTableLatenciesMetrics()).thenReturn(false); + when(metricsTableRequests.isEnabTableQueryMeterMetrics()).thenReturn(false); for (int i = 0; i < 10; i++) { - rsm.updateGet(tableName, 10); + rsm.updateGet(region, 10); } for (int i = 0; i < 11; i++) { - rsm.updateScanTime(tableName, 11); + rsm.updateScanTime(region, 11); } for (int i = 0; i < 12; i++) { - rsm.updatePut(tableName, 12); + rsm.updatePut(region, 12); } for (int i = 0; i < 13; i++) { - rsm.updateDelete(tableName, 13); + rsm.updateDelete(region, 13); } for (int i = 0; i < 14; i++) { - rsm.updateIncrement(tableName, 14); + rsm.updateIncrement(region, 14); } for (int i = 0; i < 15; i++) { - rsm.updateAppend(tableName, 15); + rsm.updateAppend(region, 15); } for (int i = 0; i < 16; i++) { rsm.updateReplay(16); @@ -150,7 +158,12 @@ public void testLossyCountingOfUserMetrics() { .doAs(new PrivilegedAction() { @Override public Void run() { - rsm.updateGet(tableName, 10); + HRegion region = mock(HRegion.class); + MetricsTableRequests metricsTableRequests = mock(MetricsTableRequests.class); + when(region.getMetricsTableRequests()).thenReturn(metricsTableRequests); + when(metricsTableRequests.isEnableTableLatenciesMetrics()).thenReturn(false); + when(metricsTableRequests.isEnabTableQueryMeterMetrics()).thenReturn(false); + rsm.updateGet(region, 10); return null; } });