keith-turner commented on code in PR #5030: URL: https://github.com/apache/accumulo/pull/5030#discussion_r1827993358
########## server/base/src/main/java/org/apache/accumulo/server/metrics/PerTableMetrics.java: ########## @@ -0,0 +1,203 @@ +/* + * 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 + * + * https://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.accumulo.server.metrics; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.TimeUnit; +import java.util.function.Consumer; +import java.util.function.Supplier; + +import org.apache.accumulo.core.conf.Property; +import org.apache.accumulo.core.data.TableId; +import org.apache.accumulo.core.manager.state.tables.TableState; +import org.apache.accumulo.core.metrics.MetricsProducer; +import org.apache.accumulo.core.util.Timer; +import org.apache.accumulo.server.ServerContext; +import org.slf4j.Logger; + +import com.google.common.base.Preconditions; + +import io.micrometer.core.instrument.Meter; +import io.micrometer.core.instrument.MeterRegistry; +import io.micrometer.core.instrument.Tag; + +/** + * Common code for dealing with per table metrics. This code handles automatically creating and + * deleting per table metrics as needed. To use this class extend and implement + * {@link #newAllTablesMetrics(MeterRegistry, Consumer, List)} and + * {@link #newPerTableMetrics(MeterRegistry, TableId, Consumer, List)} to create per table metrics + * object and then use {@link #getTableMetrics(TableId)} to get those cached objects. + */ +public abstract class PerTableMetrics<T> implements MetricsProducer { + + public static final String TABLE_ID_TAG_NAME = "tableId"; + + private final ServerContext context; + + private static class TableMetricsInfo<T2> { + final T2 tableMetrics; + volatile Timer inactiveTime; + final List<Meter> meters; + + public TableMetricsInfo(T2 tableMetrics, List<Meter> meters) { + this.tableMetrics = Objects.requireNonNull(tableMetrics); + this.meters = meters; + } + } + + private final boolean perTableActive; + private final Supplier<Set<TableId>> activeTables; + private final ConcurrentHashMap<TableId,TableMetricsInfo<T>> perTableMetrics = + new ConcurrentHashMap<>(); + private T allTableMetrics; + private volatile MeterRegistry registry; + + public PerTableMetrics(ServerContext context, Supplier<Set<TableId>> activeTableSupplier) { + activeTables = activeTableSupplier; + perTableActive = + context.getConfiguration().getBoolean(Property.GENERAL_MICROMETER_TABLE_METRICS_ENABLED); + this.context = context; + if (perTableActive) { + context.getScheduledExecutor().scheduleAtFixedRate(this::refresh, 30, 30, TimeUnit.SECONDS); + } + } + + /** + * This method exist so this class can log using the logger of the subclass. + */ + protected abstract Logger getLog(); + + /** + * Subclasses should implement this method to create a TableMetrics object that will be used in + * the case when per table metrics are disabled. The object returned by this method will alway be + * returned by {@link #getTableMetrics(TableId)} no matter what the table id is. + * + * @param registry register an meters for the table metrics in this registry + * @param meters a consumer that accepts meters to be removed from the registry when the table + * metrics object is discarded. Currently this consumer does nothing with the meters, its + * passed for consistency with + * {@link #newPerTableMetrics(MeterRegistry, TableId, Consumer, List)} + * @param tags currently an empty collection of tags, this is passed for consistency with + * {@link #PerTableMetrics(ServerContext, Supplier)} + * @return a new object that will be cached and later returned by + * {@link #getTableMetrics(TableId)} + */ + protected abstract T newAllTablesMetrics(MeterRegistry registry, Consumer<Meter> meters, + List<Tag> tags); + + /** + * + * Subclasses should implement this method to create per table table metrics objects. This method + * is called in the case where per table metrics are enabled. These objects will be cached and + * returned by {@link #getTableMetrics(TableId)}. Table metrics object in the cache that are no + * longer needed will be automatically removed when the table is deleted or this server has not + * hosted the table for a bit. + * + * @param registry register an meters for the table metrics in this registry + * @param meters a consumer that accepts meters to be removed from the registry when the per table + * metrics object is discarded. + * @param tags returns a list with a single tag in it which is the tableId. These tags should be + * used when registering meters + * @return a new object that will be cached and later returned by + * {@link #getTableMetrics(TableId)} + */ + protected abstract T newPerTableMetrics(MeterRegistry registry, TableId tableId, + Consumer<Meter> meters, List<Tag> tags); + + private TableMetricsInfo<T> getOrCreateTableMetrics(TableId tableId) { + Preconditions.checkState(perTableActive); + return perTableMetrics.computeIfAbsent(tableId, tid -> { + List<Meter> meters = new ArrayList<>(); + T tableMetrics = newPerTableMetrics(registry, tableId, meters::add, + List.of(Tag.of(TABLE_ID_TAG_NAME, tid.canonical()))); + getLog().debug("Created {} meters for table id {} in metrics registry.", meters.size(), + tableId); + return new TableMetricsInfo<>(tableMetrics, meters); + }); + } + + public void registerMetrics(MeterRegistry registry) { + Preconditions.checkState(this.registry == null); + this.registry = registry; + if (!perTableActive) { + this.allTableMetrics = newAllTablesMetrics(registry, m -> {}, List.of()); + } + } + + public T getTableMetrics(TableId tableId) { + Preconditions.checkState(registry != null); + + if (!perTableActive) { + return allTableMetrics; + } + + return getOrCreateTableMetrics(tableId).tableMetrics; + } + + /** + * This method will create per table metrics for any tables that are active on this server and + * currently have no table metrics object in the cache. It will also remove an per table metrics + * object from the cache that have been inactive for a while or where the table was deleted. + */ + public synchronized void refresh() { Review Comment: It probably would be better to do that for all cases. Its only being done for the tablet server on tablet load for this method. The three other cases you mentioned are not done. For the scan server I could not find a good place to register on tablet load, I will circle back and see what I can find. For now its probably ok that scan server does not register on load because it has no gauges, so when a scan happen it will touch meters which will load metrics. However that is shaky ground, if gauges were ever used then those may not be loaded until the timer task kicks in. Would also be good to push code to TabletHostingServer so that the metrics code can interact w/ the same code for each server type. If all 4 cases are covered with callbacks then we could run the timer task less frequently. For the unload case I was completely leaving that to the timer task to catch. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
