hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServer.java

   1 /**
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements.  See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership.  The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License.  You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18 package org.apache.hadoop.hbase.regionserver;
  19
  20 import org.apache.hadoop.hbase.CompatibilitySingletonFactory;
  21 import org.apache.hadoop.hbase.TableName;
  22 import org.apache.hadoop.hbase.metrics.Meter;
  23 import org.apache.hadoop.hbase.metrics.MetricRegistries;
  24 import org.apache.hadoop.hbase.metrics.MetricRegistry;
  25 import org.apache.hadoop.hbase.metrics.Timer;
  26 import org.apache.hadoop.conf.Configuration;
  27 import org.apache.yetus.audience.InterfaceAudience;
  28 import org.apache.yetus.audience.InterfaceStability;
  29
  30 /**
  31  * Maintains regionserver statistics and publishes them through the metrics interfaces.
  32  * This class has a number of metrics variables that are publicly accessible;
  33  * these variables (objects) have methods to update their values. Batch your updates rather than
  34  * call on each instance else all threads will do nothing but contend trying to maintain metric
  35  * counters!
  36  */
  37 @InterfaceStability.Evolving
  38 @InterfaceAudience.Private
  39 public class MetricsRegionServer {
  40   public static final String RS_ENABLE_TABLE_METRICS_KEY =
  41       "hbase.regionserver.enable.table.latencies";
  42   public static final boolean RS_ENABLE_TABLE_METRICS_DEFAULT = true;
  43   public static final String RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY =
  44       "hbase.regionserver.enable.server.query.meter";
  45   public static final boolean RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY_DEFAULT = false;
  46   public static final String RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY =
  47       "hbase.regionserver.enable.table.query.meter";
  48   public static final boolean RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT = false;
  49
  50   public static final String SLOW_METRIC_TIME = "hbase.ipc.slow.metric.time";
  51   private final MetricsRegionServerSource serverSource;
  52   private final MetricsRegionServerWrapper regionServerWrapper;
  53   private RegionServerTableMetrics tableMetrics;
  54   private final MetricsTable metricsTable;
  55   private MetricsRegionServerQuotaSource quotaSource;
  56   private final MetricsUserAggregate userAggregate;
  57
  58   private MetricRegistry metricRegistry;
  59   private Timer bulkLoadTimer;
  60   // Incremented once for each call to Scan#nextRaw
  61   private Meter serverReadQueryMeter;
  62   // Incremented per write.
  63   private Meter serverWriteQueryMeter;
  64   protected long slowMetricTime;
  65   protected static final int DEFAULT_SLOW_METRIC_TIME = 1000; // milliseconds
  66
  67   public MetricsRegionServer(MetricsRegionServerWrapper regionServerWrapper, Configuration conf,
  68       MetricsTable metricsTable) {
  69     this(regionServerWrapper,
  70         CompatibilitySingletonFactory.getInstance(MetricsRegionServerSourceFactory.class)
  71             .createServer(regionServerWrapper), createTableMetrics(conf), metricsTable,
  72         MetricsUserAggregateFactory.getMetricsUserAggregate(conf));
  73
  74     // Create hbase-metrics module based metrics. The registry should already be registered by the
  75     // MetricsRegionServerSource
  76     metricRegistry = MetricRegistries.global().get(serverSource.getMetricRegistryInfo()).get();
  77
  78     // create and use metrics from the new hbase-metrics based registry.
  79     bulkLoadTimer = metricRegistry.timer("Bulkload");
  80
  81     slowMetricTime = conf.getLong(SLOW_METRIC_TIME, DEFAULT_SLOW_METRIC_TIME);
  82     quotaSource = CompatibilitySingletonFactory.getInstance(MetricsRegionServerQuotaSource.class);
  83     if (conf.getBoolean(RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY,
  84         RS_ENABLE_SERVER_QUERY_METER_METRICS_KEY_DEFAULT)) {
  85       serverReadQueryMeter = metricRegistry.meter("ServerReadQueryPerSecond");
  86       serverWriteQueryMeter = metricRegistry.meter("ServerWriteQueryPerSecond");
  87     }
  88   }
  89
  90   MetricsRegionServer(MetricsRegionServerWrapper regionServerWrapper,
  91       MetricsRegionServerSource serverSource, RegionServerTableMetrics tableMetrics,
  92       MetricsTable metricsTable, MetricsUserAggregate userAggregate) {
  93     this.regionServerWrapper = regionServerWrapper;
  94     this.serverSource = serverSource;
  95     this.tableMetrics = tableMetrics;
  96     this.metricsTable = metricsTable;
  97     this.userAggregate = userAggregate;
  98   }
  99
 100   /**
 101    * Creates an instance of {@link RegionServerTableMetrics} only if the feature is enabled.
 102    */
 103   static RegionServerTableMetrics createTableMetrics(Configuration conf) {
 104     if (conf.getBoolean(RS_ENABLE_TABLE_METRICS_KEY, RS_ENABLE_TABLE_METRICS_DEFAULT)) {
 105       return new RegionServerTableMetrics(
 106         conf.getBoolean(RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY,
 107           RS_ENABLE_TABLE_QUERY_METER_METRICS_KEY_DEFAULT));
 108     }
 109     return null;
 110   }
 111
 112   public MetricsRegionServerSource getMetricsSource() {
 113     return serverSource;
 114   }
 115
 116   public MetricsUserAggregate getMetricsUserAggregate() {
 117     return userAggregate;
 118   }
 119
 120   public MetricsRegionServerWrapper getRegionServerWrapper() {
 121     return regionServerWrapper;
 122   }
 123
 124   public void updatePutBatch(TableName tn, long t) {
 125     if (tableMetrics != null && tn != null) {
 126       tableMetrics.updatePutBatch(tn, t);
 127     }
 128     serverSource.updatePutBatch(t);
 129   }
 130
 131   public void updatePut(TableName tn, long t) {
 132     if (tableMetrics != null && tn != null) {
 133       tableMetrics.updatePut(tn, t);
 134     }
 135     if (t > slowMetricTime) {
 136       serverSource.incrSlowPut();
 137     }
 138     serverSource.updatePut(t);
 139     userAggregate.updatePut(t);
 140   }
 141
 142   public void updateDelete(TableName tn, long t) {
 143     if (tableMetrics != null && tn != null) {
 144       tableMetrics.updateDelete(tn, t);
 145     }
 146     if (t > slowMetricTime) {
 147       serverSource.incrSlowDelete();
 148     }
 149     serverSource.updateDelete(t);
 150     userAggregate.updateDelete(t);
 151   }
 152
 153   public void updateDeleteBatch(TableName tn, long t) {
 154     if (tableMetrics != null && tn != null) {
 155       tableMetrics.updateDeleteBatch(tn, t);
 156     }
 157     serverSource.updateDeleteBatch(t);
 158   }
 159
 160   public void updateCheckAndDelete(TableName tn, long t) {
 161     if (tableMetrics != null && tn != null) {
 162       tableMetrics.updateCheckAndDelete(tn, t);
 163     }
 164     serverSource.updateCheckAndDelete(t);
 165   }
 166
 167   public void updateCheckAndPut(TableName tn, long t) {
 168     if (tableMetrics != null && tn != null) {
 169       tableMetrics.updateCheckAndPut(tn, t);
 170     }
 171     serverSource.updateCheckAndPut(t);
 172   }
 173
 174   public void updateCheckAndMutate(TableName tn, long t) {
 175     if (tableMetrics != null && tn != null) {
 176       tableMetrics.updateCheckAndMutate(tn, t);
 177     }
 178     serverSource.updateCheckAndMutate(t);
 179   }
 180
 181   public void updateGet(TableName tn, long t) {
 182     if (tableMetrics != null && tn != null) {
 183       tableMetrics.updateGet(tn, t);
 184     }
 185     if (t > slowMetricTime) {
 186       serverSource.incrSlowGet();
 187     }
 188     serverSource.updateGet(t);
 189     userAggregate.updateGet(t);
 190   }
 191
 192   public void updateIncrement(TableName tn, long t) {
 193     if (tableMetrics != null && tn != null) {
 194       tableMetrics.updateIncrement(tn, t);
 195     }
 196     if (t > slowMetricTime) {
 197       serverSource.incrSlowIncrement();
 198     }
 199     serverSource.updateIncrement(t);
 200     userAggregate.updateIncrement(t);
 201   }
 202
 203   public void updateAppend(TableName tn, long t) {
 204     if (tableMetrics != null && tn != null) {
 205       tableMetrics.updateAppend(tn, t);
 206     }
 207     if (t > slowMetricTime) {
 208       serverSource.incrSlowAppend();
 209     }
 210     serverSource.updateAppend(t);
 211     userAggregate.updateAppend(t);
 212   }
 213
 214   public void updateReplay(long t){
 215     serverSource.updateReplay(t);
 216     userAggregate.updateReplay(t);
 217   }
 218
 219   public void updateScanSize(TableName tn, long scanSize){
 220     if (tableMetrics != null && tn != null) {
 221       tableMetrics.updateScanSize(tn, scanSize);
 222     }
 223     serverSource.updateScanSize(scanSize);
 224   }
 225
 226   public void updateScanTime(TableName tn, long t) {
 227     if (tableMetrics != null && tn != null) {
 228       tableMetrics.updateScanTime(tn, t);
 229     }
 230     serverSource.updateScanTime(t);
 231     userAggregate.updateScanTime(t);
 232   }
 233
 234   public void updateSplitTime(long t) {
 235     serverSource.updateSplitTime(t);
 236   }
 237
 238   public void incrSplitRequest() {
 239     serverSource.incrSplitRequest();
 240   }
 241
 242   public void incrSplitSuccess() {
 243     serverSource.incrSplitSuccess();
 244   }
 245
 246   public void updateFlush(String table, long t, long memstoreSize, long fileSize) {
 247     serverSource.updateFlushTime(t);
 248     serverSource.updateFlushMemStoreSize(memstoreSize);
 249     serverSource.updateFlushOutputSize(fileSize);
 250
 251     if (table != null) {
 252       metricsTable.updateFlushTime(table, t);
 253       metricsTable.updateFlushMemstoreSize(table, memstoreSize);
 254       metricsTable.updateFlushOutputSize(table, fileSize);
 255     }
 256
 257   }
 258
 259   public void updateCompaction(String table, boolean isMajor, long t, int inputFileCount, int outputFileCount,
 260       long inputBytes, long outputBytes) {
 261     serverSource.updateCompactionTime(isMajor, t);
 262     serverSource.updateCompactionInputFileCount(isMajor, inputFileCount);
 263     serverSource.updateCompactionOutputFileCount(isMajor, outputFileCount);
 264     serverSource.updateCompactionInputSize(isMajor, inputBytes);
 265     serverSource.updateCompactionOutputSize(isMajor, outputBytes);
 266
 267     if (table != null) {
 268       metricsTable.updateCompactionTime(table, isMajor, t);
 269       metricsTable.updateCompactionInputFileCount(table, isMajor, inputFileCount);
 270       metricsTable.updateCompactionOutputFileCount(table, isMajor, outputFileCount);
 271       metricsTable.updateCompactionInputSize(table, isMajor, inputBytes);
 272       metricsTable.updateCompactionOutputSize(table, isMajor, outputBytes);
 273     }
 274   }
 275
 276   public void updateBulkLoad(long millis) {
 277     this.bulkLoadTimer.updateMillis(millis);
 278   }
 279
 280   /**
 281    * @see MetricsRegionServerQuotaSource#incrementNumRegionSizeReportsSent(long)
 282    */
 283   public void incrementNumRegionSizeReportsSent(long numReportsSent) {
 284     quotaSource.incrementNumRegionSizeReportsSent(numReportsSent);
 285   }
 286
 287   /**
 288    * @see MetricsRegionServerQuotaSource#incrementRegionSizeReportingChoreTime(long)
 289    */
 290   public void incrementRegionSizeReportingChoreTime(long time) {
 291     quotaSource.incrementRegionSizeReportingChoreTime(time);
 292   }
 293
 294   public void updateReadQueryMeter(TableName tn, long count) {
 295     if (tableMetrics != null && tn != null) {
 296       tableMetrics.updateTableReadQueryMeter(tn, count);
 297     }
 298     if (serverReadQueryMeter != null) {
 299       serverReadQueryMeter.mark(count);
 300     }
 301   }
 302
 303   public void updateWriteQueryMeter(TableName tn, long count) {
 304     if (tableMetrics != null && tn != null) {
 305       tableMetrics.updateTableWriteQueryMeter(tn, count);
 306     }
 307     if (serverWriteQueryMeter != null) {
 308       serverWriteQueryMeter.mark(count);
 309     }
 310   }
 311
 312   public void updateWriteQueryMeter(TableName tn) {
 313     if (tableMetrics != null && tn != null) {
 314       tableMetrics.updateTableWriteQueryMeter(tn);
 315     }
 316     if (serverWriteQueryMeter != null) {
 317       serverWriteQueryMeter.mark();
 318     }
 319   }
 320 }