solr/core/src/java/org/apache/solr/metrics/MetricSuppliers.java - lucene-solr - Git at Google

 /*
  * 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.solr.metrics;

 import java.lang.invoke.MethodHandles;
 import java.lang.management.ManagementFactory;
 import java.lang.management.ThreadMXBean;
 import java.time.Duration;
 import java.util.concurrent.Callable;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Supplier;

 import com.codahale.metrics.*;
 import org.apache.solr.core.MetricsConfig;
 import org.apache.solr.core.PluginInfo;
 import org.apache.solr.core.SolrResourceLoader;
 import org.apache.solr.util.SolrPluginUtils;
 import org.apache.solr.util.plugin.PluginInfoInitialized;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * Helper class for constructing instances of {@link com.codahale.metrics.MetricRegistry.MetricSupplier}
  * based on plugin configuration. This allows us to customize eg. {@link com.codahale.metrics.Reservoir}
  * implementations and parameters for timers and histograms.
  * <p>Custom supplier implementations must provide a zero-args constructor, and may optionally implement
  * {@link org.apache.solr.util.plugin.PluginInfoInitialized} interface for configuration - if they don't then
  * {@link org.apache.solr.util.SolrPluginUtils#invokeSetters(Object, Iterable, boolean)} will be used for initialization.</p>
  */
 public class MetricSuppliers {
   private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

   /**
    * Default {@link Counter} supplier. No configuration available.
    */
   public static final class DefaultCounterSupplier implements MetricRegistry.MetricSupplier<Counter> {
     @Override
     public Counter newMetric() {
       return new Counter();
     }
   }

   // back-compat implementation, no longer present in metrics-4
   private static final class CpuTimeClock extends Clock {
     private static final ThreadMXBean THREAD_MX_BEAN = ManagementFactory.getThreadMXBean();

     @Override
     public long getTick() {
       return THREAD_MX_BEAN.getCurrentThreadCpuTime();
     }
   }

   private static final Clock CPU_CLOCK = new CpuTimeClock();
   private static final Clock USER_CLOCK = new Clock.UserTimeClock();

   /** Clock type parameter. */
   public static final String CLOCK = "clock";
   /** User-time clock. */
   public static final String CLOCK_USER = "user";
   /** CPU-time clock. */
   public static final String CLOCK_CPU = "cpu";

   /**
    * Default {@link Meter} supplier. The following configuration is available, either as attribute
    * or initArgs:
    * <ul>
    *   <li>clock - (string) can be set to {@link #CLOCK_USER} for {@link com.codahale.metrics.Clock.UserTimeClock} or
    *   {@link #CLOCK_CPU} for {@link CpuTimeClock}. If not set then the value of
    *   {@link Clock#defaultClock()} will be used.</li>
    * </ul>
    */
   public static final class DefaultMeterSupplier implements MetricRegistry.MetricSupplier<Meter>, PluginInfoInitialized {

     public Clock clk = Clock.defaultClock();

     @Override
     public void init(PluginInfo info) {
       clk = getClock(info, CLOCK);
     }

     @Override
     public Meter newMetric() {
       return new Meter(clk);
     }

   }

   private static Clock getClock(PluginInfo info, String param) {
     if (info == null) {
       return Clock.defaultClock();
     }
     String clock = null;
     if (info.attributes != null) {
       clock = info.attributes.get(param);
     }
     if (clock == null && info.initArgs != null) {
       clock = (String)info.initArgs.get(param);
     }
     Clock clk = Clock.defaultClock();
     if (clock != null) {
       if (clock.equalsIgnoreCase(CLOCK_USER)) {
         clk = USER_CLOCK;
       } else if (clock.equalsIgnoreCase(CLOCK_CPU)) {
         clk = CPU_CLOCK;
       }
     }
     return clk;
   }

   /** Implementation class, must implement {@link Reservoir}. Supports non-standard configuration
    * of the implementations available in metrics-core.
    */
   public static final String RESERVOIR = "reservoir";
   /** Size of reservoir. */
   public static final String RESERVOIR_SIZE = "size";
   /** Alpha parameter of {@link ExponentiallyDecayingReservoir}. */
   public static final String RESERVOIR_EDR_ALPHA = "alpha";
   /** Time window in seconds of {@link SlidingTimeWindowReservoir}. */
   public static final String RESERVOIR_WINDOW = "window";

   private static final String EDR_CLAZZ = ExponentiallyDecayingReservoir.class.getName();
   private static final String UNI_CLAZZ = UniformReservoir.class.getName();
   private static final String STW_CLAZZ = SlidingTimeWindowReservoir.class.getName();
   private static final String SW_CLAZZ = SlidingWindowReservoir.class.getName();

   private static final int DEFAULT_SIZE = 1028;
   private static final double DEFAULT_ALPHA = 0.015;
   private static final long DEFAULT_WINDOW = 300;

   @SuppressWarnings({"unchecked"})
   private static final Reservoir getReservoir(SolrResourceLoader loader, PluginInfo info) {
     if (info == null) {
       return new ExponentiallyDecayingReservoir();
     }
     Clock clk = getClock(info, CLOCK);
     String clazz = ExponentiallyDecayingReservoir.class.getName();
     int size = -1;
     double alpha = -1;
     long window = -1;
     if (info.initArgs != null) {
       if (info.initArgs.get(RESERVOIR) != null) {
         String val = String.valueOf(info.initArgs.get(RESERVOIR)).trim();
         if (!val.isEmpty()) {
           clazz = val;
         }
       }
       Number n = (Number)info.initArgs.get(RESERVOIR_SIZE);
       if (n != null) {
         size = n.intValue();
       }
       n = (Number)info.initArgs.get(RESERVOIR_EDR_ALPHA);
       if (n != null) {
         alpha = n.doubleValue();
       }
       n = (Number)info.initArgs.get(RESERVOIR_WINDOW);
       if (n != null) {
         window = n.longValue();
       }
     }
     if (size <= 0) {
       size = DEFAULT_SIZE;
     }
     if (alpha <= 0) {
       alpha = DEFAULT_ALPHA;
     }
     // special case for core implementations
     if (clazz.equals(EDR_CLAZZ)) {
       return new ExponentiallyDecayingReservoir(size, alpha, clk);
     } else if (clazz.equals(UNI_CLAZZ)) {
       return new UniformReservoir(size);
     } else if (clazz.equals(STW_CLAZZ)) {
       if (window <= 0) {
         window = DEFAULT_WINDOW; // 5 minutes, comparable to EDR
       }
       return new SlidingTimeWindowReservoir(window, TimeUnit.SECONDS);
     } else if (clazz.equals(SW_CLAZZ)) {
       return new SlidingWindowReservoir(size);
     } else { // custom reservoir
       Reservoir reservoir;
       if (loader == null) {
         return new ExponentiallyDecayingReservoir(size, alpha, clk);
       } else {
         try {
           reservoir = loader.newInstance(clazz, Reservoir.class);
           if (reservoir instanceof PluginInfoInitialized) {
             ((PluginInfoInitialized)reservoir).init(info);
           } else {
             SolrPluginUtils.invokeSetters(reservoir, info.initArgs, true);
           }
           return reservoir;
         } catch (Exception e) {
           log.warn("Error initializing custom Reservoir implementation (will use default): {}", info, e);
           return new ExponentiallyDecayingReservoir(size, alpha, clk);
         }
       }
     }
   }

   /**
    * Default supplier of {@link Timer} instances, with configurable clock and reservoir.
    * See {@link DefaultMeterSupplier} for clock configuration. Reservoir configuration uses
    * {@link #RESERVOIR}, {@link #RESERVOIR_EDR_ALPHA}, {@link #RESERVOIR_SIZE} and
    * {@link #RESERVOIR_WINDOW}.
    */
   public static final class DefaultTimerSupplier implements MetricRegistry.MetricSupplier<Timer>, PluginInfoInitialized {

     public Clock clk = Clock.defaultClock();
     private PluginInfo info;
     private SolrResourceLoader loader;

     public DefaultTimerSupplier(SolrResourceLoader loader) {
       this.loader = loader;
     }

     @Override
     public void init(PluginInfo info) {
       clk = getClock(info, CLOCK);
       this.info = info;
     }

     public Reservoir getReservoir() {
       return MetricSuppliers.getReservoir(loader, info);
     }

     @Override
     public Timer newMetric() {
       return new Timer(getReservoir(), clk);
     }
   }

   /**
    * Default supplier of {@link Histogram} instances, with configurable reservoir.
    */
   public static final class DefaultHistogramSupplier implements MetricRegistry.MetricSupplier<Histogram>, PluginInfoInitialized {

     private PluginInfo info;
     private SolrResourceLoader loader;

     public DefaultHistogramSupplier(SolrResourceLoader loader) {
       this.loader = loader;
     }

     @Override
     public void init(PluginInfo info) {
       this.info = info;
     }

     public Reservoir getReservoir() {
       return MetricSuppliers.getReservoir(loader, info);
     }

     @Override
     public Histogram newMetric() {
       return new Histogram(getReservoir());
     }
   }

   /**
    * Create a {@link Counter} supplier.
    * @param loader resource loader
    * @param info plugin configuration, or null for default
    * @return configured supplier instance, or default instance if configuration was invalid
    */
   @SuppressWarnings({"unchecked"})
   public static MetricRegistry.MetricSupplier<Counter> counterSupplier(SolrResourceLoader loader, PluginInfo info) {
     if (info == null || info.className == null || info.className.trim().isEmpty()) {
       return new DefaultCounterSupplier();
     }
     if (MetricsConfig.NOOP_IMPL_CLASS.equals(info.className)) {
       return NoOpCounterSupplier.INSTANCE;
     }
     MetricRegistry.MetricSupplier<Counter> supplier;
     if (loader == null) {
       supplier = new DefaultCounterSupplier();
     } else {
       try {
         supplier = loader.newInstance(info.className, MetricRegistry.MetricSupplier.class);
       } catch (Exception e) {
         log.warn("Error creating custom Counter supplier (will use default): {}", info, e);
         supplier = new DefaultCounterSupplier();
       }
     }
     if (supplier instanceof PluginInfoInitialized) {
       ((PluginInfoInitialized)supplier).init(info);
     } else {
       SolrPluginUtils.invokeSetters(supplier, info.initArgs, true);
     }
     return supplier;
   }

   /**
    * Create a {@link Meter} supplier.
    * @param loader resource loader
    * @param info plugin configuration, or null for default
    * @return configured supplier instance, or default instance if configuration was invalid
    */
   @SuppressWarnings({"unchecked"})
   public static MetricRegistry.MetricSupplier<Meter> meterSupplier(SolrResourceLoader loader, PluginInfo info) {
     MetricRegistry.MetricSupplier<Meter> supplier;
     if (info == null || info.className == null || info.className.isEmpty()) {
       supplier = new DefaultMeterSupplier();
     } else {
       if (MetricsConfig.NOOP_IMPL_CLASS.equals(info.className)) {
         return NoOpMeterSupplier.INSTANCE;
       }
       if (loader == null) {
         supplier = new DefaultMeterSupplier();
       } else {
         try {
           supplier = loader.newInstance(info.className, MetricRegistry.MetricSupplier.class);
         } catch (Exception e) {
           log.warn("Error creating custom Meter supplier (will use default): {}",info, e);
           supplier = new DefaultMeterSupplier();
         }
       }
     }
     if (supplier instanceof PluginInfoInitialized) {
       ((PluginInfoInitialized)supplier).init(info);
     } else {
       SolrPluginUtils.invokeSetters(supplier, info.initArgs, true);
     }
     return supplier;
   }

   /**
    * Create a {@link Timer} supplier.
    * @param loader resource loader
    * @param info plugin configuration, or null for default
    * @return configured supplier instance, or default instance if configuration was invalid
    */
   @SuppressWarnings({"unchecked"})
   public static MetricRegistry.MetricSupplier<Timer> timerSupplier(SolrResourceLoader loader, PluginInfo info) {
     MetricRegistry.MetricSupplier<Timer> supplier;
     if (info == null || info.className == null || info.className.isEmpty()) {
       supplier = new DefaultTimerSupplier(loader);
     } else {
       if (MetricsConfig.NOOP_IMPL_CLASS.equals(info.className)) {
         return NoOpTimerSupplier.INSTANCE;
       }
       if (loader == null) {
         supplier = new DefaultTimerSupplier(null);
       } else {
         try {
           supplier = loader.newInstance(info.className, MetricRegistry.MetricSupplier.class);
         } catch (Exception e) {
           log.warn("Error creating custom Timer supplier (will use default): {}", info, e);
           supplier = new DefaultTimerSupplier(loader);
         }
       }
     }
     if (supplier instanceof PluginInfoInitialized) {
       ((PluginInfoInitialized)supplier).init(info);
     } else {
       SolrPluginUtils.invokeSetters(supplier, info.initArgs, true);
     }
     return supplier;
   }

   /**
    * Create a {@link Histogram} supplier.
    * @param info plugin configuration, or null for default
    * @return configured supplier instance, or default instance if configuration was invalid
    */
   @SuppressWarnings({"unchecked"})
   public static MetricRegistry.MetricSupplier<Histogram> histogramSupplier(SolrResourceLoader loader, PluginInfo info) {
     MetricRegistry.MetricSupplier<Histogram> supplier;
     if (info == null || info.className == null || info.className.isEmpty()) {
       supplier = new DefaultHistogramSupplier(loader);
     } else {
       if (MetricsConfig.NOOP_IMPL_CLASS.equals(info.className)) {
         return NoOpHistogramSupplier.INSTANCE;
       }
       if (loader == null) {
         supplier = new DefaultHistogramSupplier(null);
       } else {
         try {
           supplier = loader.newInstance(info.className, MetricRegistry.MetricSupplier.class);
         } catch (Exception e) {
           log.warn("Error creating custom Histogram supplier (will use default): {}", info, e);
           supplier = new DefaultHistogramSupplier(loader);
         }
       }
     }
     if (supplier instanceof PluginInfoInitialized) {
       ((PluginInfoInitialized)supplier).init(info);
     } else {
       SolrPluginUtils.invokeSetters(supplier, info.initArgs, true);
     }
     return supplier;
   }

   // NO-OP implementations. These can be used to effectively "turn off" the metrics
   // collection, or rather eliminate the overhead of the metrics accounting and their
   // memory footprint.

   /**
    * Marker interface for all no-op metrics.
    */
   public interface NoOpMetric {

   }

   /**
    * No-op implementation of {@link Counter} supplier.
    */
   public static final class NoOpCounterSupplier implements MetricRegistry.MetricSupplier<Counter> {
     public static final NoOpCounterSupplier INSTANCE = new NoOpCounterSupplier();

     private static final class NoOpCounter extends Counter implements NoOpMetric {
       @Override
       public void inc() {
         // no-op
       }

       @Override
       public void inc(long n) {
         // no-op
       }

       @Override
       public void dec() {
         // no-op
       }

       @Override
       public void dec(long n) {
         // no-op
       }
     }

     private static final Counter METRIC = new NoOpCounter();

     @Override
     public Counter newMetric() {
       return METRIC;
     }
   }

   /**
    * No-op implementation of {@link Histogram} supplier.
    */
   public static final class NoOpHistogramSupplier implements MetricRegistry.MetricSupplier<Histogram> {
     public static final NoOpHistogramSupplier INSTANCE = new NoOpHistogramSupplier();

     private static final class NoOpHistogram extends Histogram implements NoOpMetric {

       public NoOpHistogram() {
         super(new UniformReservoir(1));
       }

       @Override
       public void update(int value) {
         // no-op
       }

       @Override
       public void update(long value) {
         // no-op
       }
     }

     private static final NoOpHistogram METRIC = new NoOpHistogram();

     @Override
     public Histogram newMetric() {
       return METRIC;
     }
   }

   /**
    * No-op implementation of {@link Meter} supplier.
    */
   public static final class NoOpMeterSupplier implements MetricRegistry.MetricSupplier<Meter> {
     public static final NoOpMeterSupplier INSTANCE = new NoOpMeterSupplier();

     private static final class NoOpMeter extends Meter implements NoOpMetric {
       @Override
       public void mark() {
         // no-op
       }

       @Override
       public void mark(long n) {
         // no-op
       }
     }

     private static final NoOpMeter METRIC = new NoOpMeter();

     @Override
     public Meter newMetric() {
       return METRIC;
     }
   }

   /**
    * No-op implementation of {@link Timer} supplier.
    */
   public static final class NoOpTimerSupplier implements MetricRegistry.MetricSupplier<Timer> {
     public static final NoOpTimerSupplier INSTANCE = new NoOpTimerSupplier();

     private static final class NoOpTimer extends Timer implements NoOpMetric {
       @Override
       public void update(long duration, TimeUnit unit) {
         // no-op
       }

       @Override
       public void update(Duration duration) {
         // no-op
       }

       @Override
       public <T> T time(Callable<T> event) throws Exception {
         return event.call();
       }

       @Override
       public <T> T timeSupplier(Supplier<T> event) {
         return event.get();
       }

       @Override
       public void time(Runnable event) {
         event.run();
       }
     }

     private static final NoOpTimer METRIC = new NoOpTimer();

     @Override
     public Timer newMetric() {
       return METRIC;
     }
   }

   /**
    * No-op implementation of {@link Gauge}.
    */
   public static final class NoOpGauge implements Gauge<Object>, NoOpMetric {
     public static final NoOpGauge INSTANCE = new NoOpGauge();

     @Override
     public Object getValue() {
       return null;
     }
   }

   @SuppressWarnings("unchecked")
   public static <T> Gauge<T> getNoOpGauge(Gauge<T> actual) {
     return (Gauge<T>) NoOpGauge.INSTANCE;
   }
 }
	/*
	* 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.solr.metrics;

	import java.lang.invoke.MethodHandles;
	import java.lang.management.ManagementFactory;
	import java.lang.management.ThreadMXBean;
	import java.time.Duration;
	import java.util.concurrent.Callable;
	import java.util.concurrent.TimeUnit;
	import java.util.function.Supplier;

	import com.codahale.metrics.*;
	import org.apache.solr.core.MetricsConfig;
	import org.apache.solr.core.PluginInfo;
	import org.apache.solr.core.SolrResourceLoader;
	import org.apache.solr.util.SolrPluginUtils;
	import org.apache.solr.util.plugin.PluginInfoInitialized;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	/**
	* Helper class for constructing instances of {@link com.codahale.metrics.MetricRegistry.MetricSupplier}
	* based on plugin configuration. This allows us to customize eg. {@link com.codahale.metrics.Reservoir}
	* implementations and parameters for timers and histograms.
	* <p>Custom supplier implementations must provide a zero-args constructor, and may optionally implement
	* {@link org.apache.solr.util.plugin.PluginInfoInitialized} interface for configuration - if they don't then
	* {@link org.apache.solr.util.SolrPluginUtils#invokeSetters(Object, Iterable, boolean)} will be used for initialization.</p>
	*/
	public class MetricSuppliers {
	private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

	/**
	* Default {@link Counter} supplier. No configuration available.
	*/
	public static final class DefaultCounterSupplier implements MetricRegistry.MetricSupplier<Counter> {
	@Override
	public Counter newMetric() {
	return new Counter();
	}
	}

	// back-compat implementation, no longer present in metrics-4
	private static final class CpuTimeClock extends Clock {
	private static final ThreadMXBean THREAD_MX_BEAN = ManagementFactory.getThreadMXBean();

	@Override
	public long getTick() {
	return THREAD_MX_BEAN.getCurrentThreadCpuTime();
	}
	}

	private static final Clock CPU_CLOCK = new CpuTimeClock();
	private static final Clock USER_CLOCK = new Clock.UserTimeClock();

	/** Clock type parameter. */
	public static final String CLOCK = "clock";
	/** User-time clock. */
	public static final String CLOCK_USER = "user";
	/** CPU-time clock. */
	public static final String CLOCK_CPU = "cpu";

	/**
	* Default {@link Meter} supplier. The following configuration is available, either as attribute
	* or initArgs:
	* <ul>
	* <li>clock - (string) can be set to {@link #CLOCK_USER} for {@link com.codahale.metrics.Clock.UserTimeClock} or
	* {@link #CLOCK_CPU} for {@link CpuTimeClock}. If not set then the value of
	* {@link Clock#defaultClock()} will be used.</li>
	* </ul>
	*/
	public static final class DefaultMeterSupplier implements MetricRegistry.MetricSupplier<Meter>, PluginInfoInitialized {

	public Clock clk = Clock.defaultClock();

	@Override
	public void init(PluginInfo info) {
	clk = getClock(info, CLOCK);
	}

	@Override
	public Meter newMetric() {
	return new Meter(clk);
	}

	}

	private static Clock getClock(PluginInfo info, String param) {
	if (info == null) {
	return Clock.defaultClock();
	}
	String clock = null;
	if (info.attributes != null) {
	clock = info.attributes.get(param);
	}
	if (clock == null && info.initArgs != null) {
	clock = (String)info.initArgs.get(param);
	}
	Clock clk = Clock.defaultClock();
	if (clock != null) {
	if (clock.equalsIgnoreCase(CLOCK_USER)) {
	clk = USER_CLOCK;
	} else if (clock.equalsIgnoreCase(CLOCK_CPU)) {
	clk = CPU_CLOCK;
	}
	}
	return clk;
	}

	/** Implementation class, must implement {@link Reservoir}. Supports non-standard configuration
	* of the implementations available in metrics-core.
	*/
	public static final String RESERVOIR = "reservoir";
	/** Size of reservoir. */
	public static final String RESERVOIR_SIZE = "size";
	/** Alpha parameter of {@link ExponentiallyDecayingReservoir}. */
	public static final String RESERVOIR_EDR_ALPHA = "alpha";
	/** Time window in seconds of {@link SlidingTimeWindowReservoir}. */
	public static final String RESERVOIR_WINDOW = "window";

	private static final String EDR_CLAZZ = ExponentiallyDecayingReservoir.class.getName();
	private static final String UNI_CLAZZ = UniformReservoir.class.getName();
	private static final String STW_CLAZZ = SlidingTimeWindowReservoir.class.getName();
	private static final String SW_CLAZZ = SlidingWindowReservoir.class.getName();

	private static final int DEFAULT_SIZE = 1028;
	private static final double DEFAULT_ALPHA = 0.015;
	private static final long DEFAULT_WINDOW = 300;

	@SuppressWarnings({"unchecked"})
	private static final Reservoir getReservoir(SolrResourceLoader loader, PluginInfo info) {
	if (info == null) {
	return new ExponentiallyDecayingReservoir();
	}
	Clock clk = getClock(info, CLOCK);
	String clazz = ExponentiallyDecayingReservoir.class.getName();
	int size = -1;
	double alpha = -1;
	long window = -1;
	if (info.initArgs != null) {
	if (info.initArgs.get(RESERVOIR) != null) {
	String val = String.valueOf(info.initArgs.get(RESERVOIR)).trim();
	if (!val.isEmpty()) {
	clazz = val;
	}
	}
	Number n = (Number)info.initArgs.get(RESERVOIR_SIZE);
	if (n != null) {
	size = n.intValue();
	}
	n = (Number)info.initArgs.get(RESERVOIR_EDR_ALPHA);
	if (n != null) {
	alpha = n.doubleValue();
	}
	n = (Number)info.initArgs.get(RESERVOIR_WINDOW);
	if (n != null) {
	window = n.longValue();
	}
	}
	if (size <= 0) {
	size = DEFAULT_SIZE;
	}
	if (alpha <= 0) {
	alpha = DEFAULT_ALPHA;
	}
	// special case for core implementations
	if (clazz.equals(EDR_CLAZZ)) {
	return new ExponentiallyDecayingReservoir(size, alpha, clk);
	} else if (clazz.equals(UNI_CLAZZ)) {
	return new UniformReservoir(size);
	} else if (clazz.equals(STW_CLAZZ)) {
	if (window <= 0) {
	window = DEFAULT_WINDOW; // 5 minutes, comparable to EDR
	}
	return new SlidingTimeWindowReservoir(window, TimeUnit.SECONDS);
	} else if (clazz.equals(SW_CLAZZ)) {
	return new SlidingWindowReservoir(size);
	} else { // custom reservoir
	Reservoir reservoir;
	if (loader == null) {
	return new ExponentiallyDecayingReservoir(size, alpha, clk);
	} else {
	try {
	reservoir = loader.newInstance(clazz, Reservoir.class);
	if (reservoir instanceof PluginInfoInitialized) {
	((PluginInfoInitialized)reservoir).init(info);
	} else {
	SolrPluginUtils.invokeSetters(reservoir, info.initArgs, true);
	}
	return reservoir;
	} catch (Exception e) {
	log.warn("Error initializing custom Reservoir implementation (will use default): {}", info, e);
	return new ExponentiallyDecayingReservoir(size, alpha, clk);
	}
	}
	}
	}

	/**
	* Default supplier of {@link Timer} instances, with configurable clock and reservoir.
	* See {@link DefaultMeterSupplier} for clock configuration. Reservoir configuration uses
	* {@link #RESERVOIR}, {@link #RESERVOIR_EDR_ALPHA}, {@link #RESERVOIR_SIZE} and
	* {@link #RESERVOIR_WINDOW}.
	*/
	public static final class DefaultTimerSupplier implements MetricRegistry.MetricSupplier<Timer>, PluginInfoInitialized {

	public Clock clk = Clock.defaultClock();
	private PluginInfo info;
	private SolrResourceLoader loader;

	public DefaultTimerSupplier(SolrResourceLoader loader) {
	this.loader = loader;
	}

	@Override
	public void init(PluginInfo info) {
	clk = getClock(info, CLOCK);
	this.info = info;
	}

	public Reservoir getReservoir() {
	return MetricSuppliers.getReservoir(loader, info);
	}

	@Override
	public Timer newMetric() {
	return new Timer(getReservoir(), clk);
	}
	}

	/**
	* Default supplier of {@link Histogram} instances, with configurable reservoir.
	*/
	public static final class DefaultHistogramSupplier implements MetricRegistry.MetricSupplier<Histogram>, PluginInfoInitialized {

	private PluginInfo info;
	private SolrResourceLoader loader;

	public DefaultHistogramSupplier(SolrResourceLoader loader) {
	this.loader = loader;
	}

	@Override
	public void init(PluginInfo info) {
	this.info = info;
	}

	public Reservoir getReservoir() {
	return MetricSuppliers.getReservoir(loader, info);
	}

	@Override
	public Histogram newMetric() {
	return new Histogram(getReservoir());
	}
	}

	/**
	* Create a {@link Counter} supplier.
	* @param loader resource loader
	* @param info plugin configuration, or null for default
	* @return configured supplier instance, or default instance if configuration was invalid
	*/
	@SuppressWarnings({"unchecked"})
	public static MetricRegistry.MetricSupplier<Counter> counterSupplier(SolrResourceLoader loader, PluginInfo info) {
	if (info == null \|\| info.className == null \|\| info.className.trim().isEmpty()) {
	return new DefaultCounterSupplier();
	}
	if (MetricsConfig.NOOP_IMPL_CLASS.equals(info.className)) {
	return NoOpCounterSupplier.INSTANCE;
	}
	MetricRegistry.MetricSupplier<Counter> supplier;
	if (loader == null) {
	supplier = new DefaultCounterSupplier();
	} else {
	try {
	supplier = loader.newInstance(info.className, MetricRegistry.MetricSupplier.class);
	} catch (Exception e) {
	log.warn("Error creating custom Counter supplier (will use default): {}", info, e);
	supplier = new DefaultCounterSupplier();
	}
	}
	if (supplier instanceof PluginInfoInitialized) {
	((PluginInfoInitialized)supplier).init(info);
	} else {
	SolrPluginUtils.invokeSetters(supplier, info.initArgs, true);
	}
	return supplier;
	}

	/**
	* Create a {@link Meter} supplier.
	* @param loader resource loader
	* @param info plugin configuration, or null for default
	* @return configured supplier instance, or default instance if configuration was invalid
	*/
	@SuppressWarnings({"unchecked"})
	public static MetricRegistry.MetricSupplier<Meter> meterSupplier(SolrResourceLoader loader, PluginInfo info) {
	MetricRegistry.MetricSupplier<Meter> supplier;
	if (info == null \|\| info.className == null \|\| info.className.isEmpty()) {
	supplier = new DefaultMeterSupplier();
	} else {
	if (MetricsConfig.NOOP_IMPL_CLASS.equals(info.className)) {
	return NoOpMeterSupplier.INSTANCE;
	}
	if (loader == null) {
	supplier = new DefaultMeterSupplier();
	} else {
	try {
	supplier = loader.newInstance(info.className, MetricRegistry.MetricSupplier.class);
	} catch (Exception e) {
	log.warn("Error creating custom Meter supplier (will use default): {}",info, e);
	supplier = new DefaultMeterSupplier();
	}
	}
	}
	if (supplier instanceof PluginInfoInitialized) {
	((PluginInfoInitialized)supplier).init(info);
	} else {
	SolrPluginUtils.invokeSetters(supplier, info.initArgs, true);
	}
	return supplier;
	}

	/**
	* Create a {@link Timer} supplier.
	* @param loader resource loader
	* @param info plugin configuration, or null for default
	* @return configured supplier instance, or default instance if configuration was invalid
	*/
	@SuppressWarnings({"unchecked"})
	public static MetricRegistry.MetricSupplier<Timer> timerSupplier(SolrResourceLoader loader, PluginInfo info) {
	MetricRegistry.MetricSupplier<Timer> supplier;
	if (info == null \|\| info.className == null \|\| info.className.isEmpty()) {
	supplier = new DefaultTimerSupplier(loader);
	} else {
	if (MetricsConfig.NOOP_IMPL_CLASS.equals(info.className)) {
	return NoOpTimerSupplier.INSTANCE;
	}
	if (loader == null) {
	supplier = new DefaultTimerSupplier(null);
	} else {
	try {
	supplier = loader.newInstance(info.className, MetricRegistry.MetricSupplier.class);
	} catch (Exception e) {
	log.warn("Error creating custom Timer supplier (will use default): {}", info, e);
	supplier = new DefaultTimerSupplier(loader);
	}
	}
	}
	if (supplier instanceof PluginInfoInitialized) {
	((PluginInfoInitialized)supplier).init(info);
	} else {
	SolrPluginUtils.invokeSetters(supplier, info.initArgs, true);
	}
	return supplier;
	}

	/**
	* Create a {@link Histogram} supplier.
	* @param info plugin configuration, or null for default
	* @return configured supplier instance, or default instance if configuration was invalid
	*/
	@SuppressWarnings({"unchecked"})
	public static MetricRegistry.MetricSupplier<Histogram> histogramSupplier(SolrResourceLoader loader, PluginInfo info) {
	MetricRegistry.MetricSupplier<Histogram> supplier;
	if (info == null \|\| info.className == null \|\| info.className.isEmpty()) {
	supplier = new DefaultHistogramSupplier(loader);
	} else {
	if (MetricsConfig.NOOP_IMPL_CLASS.equals(info.className)) {
	return NoOpHistogramSupplier.INSTANCE;
	}
	if (loader == null) {
	supplier = new DefaultHistogramSupplier(null);
	} else {
	try {
	supplier = loader.newInstance(info.className, MetricRegistry.MetricSupplier.class);
	} catch (Exception e) {
	log.warn("Error creating custom Histogram supplier (will use default): {}", info, e);
	supplier = new DefaultHistogramSupplier(loader);
	}
	}
	}
	if (supplier instanceof PluginInfoInitialized) {
	((PluginInfoInitialized)supplier).init(info);
	} else {
	SolrPluginUtils.invokeSetters(supplier, info.initArgs, true);
	}
	return supplier;
	}

	// NO-OP implementations. These can be used to effectively "turn off" the metrics
	// collection, or rather eliminate the overhead of the metrics accounting and their
	// memory footprint.

	/**
	* Marker interface for all no-op metrics.
	*/
	public interface NoOpMetric {

	}

	/**
	* No-op implementation of {@link Counter} supplier.
	*/
	public static final class NoOpCounterSupplier implements MetricRegistry.MetricSupplier<Counter> {
	public static final NoOpCounterSupplier INSTANCE = new NoOpCounterSupplier();

	private static final class NoOpCounter extends Counter implements NoOpMetric {
	@Override
	public void inc() {
	// no-op
	}

	@Override
	public void inc(long n) {
	// no-op
	}

	@Override
	public void dec() {
	// no-op
	}

	@Override
	public void dec(long n) {
	// no-op
	}
	}

	private static final Counter METRIC = new NoOpCounter();

	@Override
	public Counter newMetric() {
	return METRIC;
	}
	}

	/**
	* No-op implementation of {@link Histogram} supplier.
	*/
	public static final class NoOpHistogramSupplier implements MetricRegistry.MetricSupplier<Histogram> {
	public static final NoOpHistogramSupplier INSTANCE = new NoOpHistogramSupplier();

	private static final class NoOpHistogram extends Histogram implements NoOpMetric {

	public NoOpHistogram() {
	super(new UniformReservoir(1));
	}

	@Override
	public void update(int value) {
	// no-op
	}

	@Override
	public void update(long value) {
	// no-op
	}
	}

	private static final NoOpHistogram METRIC = new NoOpHistogram();

	@Override
	public Histogram newMetric() {
	return METRIC;
	}
	}

	/**
	* No-op implementation of {@link Meter} supplier.
	*/
	public static final class NoOpMeterSupplier implements MetricRegistry.MetricSupplier<Meter> {
	public static final NoOpMeterSupplier INSTANCE = new NoOpMeterSupplier();

	private static final class NoOpMeter extends Meter implements NoOpMetric {
	@Override
	public void mark() {
	// no-op
	}

	@Override
	public void mark(long n) {
	// no-op
	}
	}

	private static final NoOpMeter METRIC = new NoOpMeter();

	@Override
	public Meter newMetric() {
	return METRIC;
	}
	}

	/**
	* No-op implementation of {@link Timer} supplier.
	*/
	public static final class NoOpTimerSupplier implements MetricRegistry.MetricSupplier<Timer> {
	public static final NoOpTimerSupplier INSTANCE = new NoOpTimerSupplier();

	private static final class NoOpTimer extends Timer implements NoOpMetric {
	@Override
	public void update(long duration, TimeUnit unit) {
	// no-op
	}

	@Override
	public void update(Duration duration) {
	// no-op
	}

	@Override
	public <T> T time(Callable<T> event) throws Exception {
	return event.call();
	}

	@Override
	public <T> T timeSupplier(Supplier<T> event) {
	return event.get();
	}

	@Override
	public void time(Runnable event) {
	event.run();
	}
	}

	private static final NoOpTimer METRIC = new NoOpTimer();

	@Override
	public Timer newMetric() {
	return METRIC;
	}
	}

	/**
	* No-op implementation of {@link Gauge}.
	*/
	public static final class NoOpGauge implements Gauge<Object>, NoOpMetric {
	public static final NoOpGauge INSTANCE = new NoOpGauge();

	@Override
	public Object getValue() {
	return null;
	}
	}

	@SuppressWarnings("unchecked")
	public static <T> Gauge<T> getNoOpGauge(Gauge<T> actual) {
	return (Gauge<T>) NoOpGauge.INSTANCE;
	}
	}