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.metrics.impl;
019
020import java.util.Collection;
021import java.util.HashMap;
022import java.util.Iterator;
023import java.util.Map.Entry;
024import java.util.Optional;
025import java.util.concurrent.TimeUnit;
026import java.util.concurrent.atomic.AtomicBoolean;
027import org.apache.hadoop.hbase.metrics.MetricRegistries;
028import org.apache.hadoop.hbase.metrics.MetricRegistry;
029import org.apache.hadoop.hbase.metrics.MetricRegistryInfo;
030import org.apache.hadoop.metrics2.MetricsCollector;
031import org.apache.hadoop.metrics2.MetricsExecutor;
032import org.apache.hadoop.metrics2.MetricsSource;
033import org.apache.hadoop.metrics2.impl.JmxCacheBuster;
034import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
035import org.apache.hadoop.metrics2.lib.DefaultMetricsSystemHelper;
036import org.apache.hadoop.metrics2.lib.MetricsExecutorImpl;
037import org.apache.yetus.audience.InterfaceAudience;
038import org.slf4j.Logger;
039import org.slf4j.LoggerFactory;
040
041/**
042 * This class acts as an adapter to export the MetricRegistry's in the global registry. Each
043 * MetricRegistry will be registered or unregistered from the metric2 system. The collection will be
044 * performed via the MetricsSourceAdapter and the MetricRegistry will collected like a BaseSource
045 * instance for a group of metrics (like WAL, RPC, etc) with the MetricRegistryInfo's JMX context.
046 * <p>
047 * Developer note: Unlike the current metrics2 based approach, the new metrics approach
048 * (hbase-metrics-api and hbase-metrics modules) work by having different MetricRegistries that are
049 * initialized and used from the code that lives in their respective modules (hbase-server, etc).
050 * There is no need to define BaseSource classes and do a lot of indirection. The MetricRegistry'es
051 * will be in the global MetricRegistriesImpl, and this class will iterate over
052 * MetricRegistries.global() and register adapters to the metrics2 subsystem. These adapters then
053 * report the actual values by delegating to
054 * {@link HBaseMetrics2HadoopMetricsAdapter#snapshotAllMetrics(MetricRegistry, MetricsCollector)}.
055 * We do not initialize the Hadoop Metrics2 system assuming that other BaseSources already do so
056 * (see BaseSourceImpl). Once the last BaseSource is moved to the new system, the metric2
057 * initialization should be moved here.
058 * </p>
059 */
060@InterfaceAudience.Private
061public final class GlobalMetricRegistriesAdapter {
062
063  private static final Logger LOG = LoggerFactory.getLogger(GlobalMetricRegistriesAdapter.class);
064
065  private class MetricsSourceAdapter implements MetricsSource {
066    private final MetricRegistry registry;
067
068    MetricsSourceAdapter(MetricRegistry registry) {
069      this.registry = registry;
070    }
071
072    @Override
073    public void getMetrics(MetricsCollector collector, boolean all) {
074      metricsAdapter.snapshotAllMetrics(registry, collector);
075    }
076  }
077
078  private final MetricsExecutor executor;
079  private final AtomicBoolean stopped;
080  private final DefaultMetricsSystemHelper helper;
081  private final HBaseMetrics2HadoopMetricsAdapter metricsAdapter;
082  private final HashMap<MetricRegistryInfo, MetricsSourceAdapter> registeredSources;
083
084  private GlobalMetricRegistriesAdapter() {
085    this.executor = new MetricsExecutorImpl();
086    this.stopped = new AtomicBoolean(false);
087    this.metricsAdapter = new HBaseMetrics2HadoopMetricsAdapter();
088    this.registeredSources = new HashMap<>();
089    this.helper = new DefaultMetricsSystemHelper();
090    executor.getExecutor().scheduleAtFixedRate(() -> this.doRun(), 10, 10, TimeUnit.SECONDS);
091  }
092
093  /**
094   * Make sure that this global MetricSource for hbase-metrics module based metrics are initialized.
095   * This should be called only once.
096   */
097  public static GlobalMetricRegistriesAdapter init() {
098    return new GlobalMetricRegistriesAdapter();
099  }
100
101  public void stop() {
102    stopped.set(true);
103  }
104
105  private void doRun() {
106    if (stopped.get()) {
107      executor.stop();
108      return;
109    }
110    if (LOG.isTraceEnabled()) {
111      LOG.trace("doRun called: " + registeredSources);
112    }
113
114    Collection<MetricRegistry> registries = MetricRegistries.global().getMetricRegistries();
115    for (MetricRegistry registry : registries) {
116      MetricRegistryInfo info = registry.getMetricRegistryInfo();
117
118      if (info.isExistingSource()) {
119        // If there is an already existing BaseSource for this MetricRegistry, skip it here. These
120        // types of registries are there only due to existing BaseSource implementations in the
121        // source code (like MetricsRegionServer, etc). This is to make sure that we can transition
122        // iteratively to the new hbase-metrics system. These type of MetricRegistry metrics will be
123        // exported from the BaseSource.getMetrics() call directly because there is already a
124        // MetricRecordBuilder there (see MetricsRegionServerSourceImpl).
125        continue;
126      }
127
128      if (!registeredSources.containsKey(info)) {
129        if (LOG.isDebugEnabled()) {
130          LOG.debug("Registering adapter for the MetricRegistry: " + info.getMetricsJmxContext());
131        }
132        // register this as a MetricSource under different JMX Context'es.
133        MetricsSourceAdapter adapter = new MetricsSourceAdapter(registry);
134        LOG.info("Registering " + info.getMetricsJmxContext() + " " + info.getMetricsDescription());
135        DefaultMetricsSystem.instance().register(info.getMetricsJmxContext(),
136          info.getMetricsDescription(), adapter);
137        registeredSources.put(info, adapter);
138        // next collection will collect the newly registered MetricSource. Doing this here leads to
139        // ConcurrentModificationException.
140      }
141    }
142
143    boolean removed = false;
144    // Remove registered sources if it is removed from the global registry
145    for (Iterator<Entry<MetricRegistryInfo, MetricsSourceAdapter>> it =
146      registeredSources.entrySet().iterator(); it.hasNext();) {
147      Entry<MetricRegistryInfo, MetricsSourceAdapter> entry = it.next();
148      MetricRegistryInfo info = entry.getKey();
149      Optional<MetricRegistry> found = MetricRegistries.global().get(info);
150      if (!found.isPresent()) {
151        if (LOG.isDebugEnabled()) {
152          LOG.debug("Removing adapter for the MetricRegistry: " + info.getMetricsJmxContext());
153        }
154        synchronized (DefaultMetricsSystem.instance()) {
155          DefaultMetricsSystem.instance().unregisterSource(info.getMetricsJmxContext());
156          helper.removeSourceName(info.getMetricsJmxContext());
157          helper.removeObjectName(info.getMetricsJmxContext());
158          it.remove();
159          removed = true;
160        }
161      }
162    }
163    if (removed) {
164      JmxCacheBuster.clearJmxCache();
165    }
166  }
167}