src/main/java/com/baidu/hugegraph/stats/MetricsManager.java - incubator-hugegraph-commons - Git at Google

 /*
  * Copyright 2017 HugeGraph Authors
  *
  * 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 com.baidu.hugegraph.stats;

 import java.io.File;
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.time.Duration;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;

 import javax.management.MBeanServer;
 import javax.management.MBeanServerFactory;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import com.baidu.hugegraph.util.Log;
 import com.codahale.metrics.ConsoleReporter;
 import com.codahale.metrics.Counter;
 import com.codahale.metrics.CsvReporter;
 import com.codahale.metrics.Histogram;
 import com.codahale.metrics.JmxReporter;
 import com.codahale.metrics.MetricFilter;
 import com.codahale.metrics.MetricRegistry;
 import com.codahale.metrics.Slf4jReporter;
 import com.codahale.metrics.Timer;
 import com.codahale.metrics.ganglia.GangliaReporter;
 import com.codahale.metrics.graphite.Graphite;
 import com.codahale.metrics.graphite.GraphiteReporter;
 import com.google.common.base.Preconditions;

 import info.ganglia.gmetric4j.gmetric.GMetric;
 import info.ganglia.gmetric4j.gmetric.GMetric.UDPAddressingMode;

 /**
  * Singleton that contains and configures HugeGraph's {@code MetricRegistry}.
  */
 public class MetricsManager {

     private static final Logger LOG = Log.logger(MetricsManager.class);

     private static final MetricsManager INSTANCE = new MetricsManager();

     private final MetricRegistry registry;
     private ConsoleReporter consoleReporter = null;
     private CsvReporter csvReporter = null;
     private JmxReporter jmxReporter = null;
     private Slf4jReporter slf4jReporter = null;
     private GangliaReporter gangliaReporter = null;
     private GraphiteReporter graphiteReporter = null;

     /**
      * Private constructor for singleton.
      */
     private MetricsManager() {
         this.registry = new MetricRegistry();
     }

     /**
      * Return the Singleton Metrics Manager.
      *
      * @return the single {@code MetricManager}
      */
     public static MetricsManager instance() {
         return INSTANCE;
     }

     /**
      * Return the HugeGraph Metrics registry.
      *
      * @return the single {@code MetricRegistry} used for all of HugeGraph's
      *         Metrics monitoring
      */
     public MetricRegistry getRegistry() {
         return this.registry;
     }

     /**
      * Create a {@link ConsoleReporter} attached to the HugeGraph Metrics
      * registry.
      *
      * @param reportInterval
      *            time to wait between dumping metrics to the console
      */
     public synchronized void addConsoleReporter(Duration reportInterval) {
         if (this.consoleReporter != null) {
             LOG.debug("Metrics ConsoleReporter already active");
             return;
         }

         this.consoleReporter = ConsoleReporter.forRegistry(getRegistry()).build();
         this.consoleReporter.start(reportInterval.toMillis(), TimeUnit.MILLISECONDS);
     }

     /**
      * Stop a {@link ConsoleReporter} previously created by a call to
      * {@link #addConsoleReporter(Duration)} and release it for GC. Idempotent
      * between calls to the associated add method. Does nothing before the first
      * call to the associated add method.
      */
     public synchronized void removeConsoleReporter() {
         if (this.consoleReporter != null) {
             this.consoleReporter.stop();
         }
         this.consoleReporter = null;
     }

     /**
      * Create a {@link CsvReporter} attached to the HugeGraph Metrics registry.
      * <p>
      * The {@code output} argument must be non-null but need not exist. If it
      * doesn't already exist, this method attempts to create it by calling
      * {@link File#mkdirs()}.
      *
      * @param reportInterval
      *            time to wait between dumping metrics to CSV files in
      *            the configured directory
      * @param output
      *            the path to a directory into which Metrics will periodically
      *            write CSV data
      */
     public synchronized void addCsvReporter(Duration reportInterval,
                                             String output) {

         File outputDir = new File(output);

         if (this.csvReporter != null) {
             LOG.debug("Metrics CsvReporter already active");
             return;
         }

         if (!outputDir.exists()) {
             if (!outputDir.mkdirs()) {
                 LOG.warn("Failed to create CSV metrics dir {}", outputDir);
             }
         }

         this.csvReporter = CsvReporter.forRegistry(getRegistry()).build(outputDir);
         this.csvReporter.start(reportInterval.toMillis(), TimeUnit.MILLISECONDS);
     }

     /**
      * Stop a {@link CsvReporter} previously created by a call to
      * {@link #addCsvReporter(Duration, String)} and release it for GC.
      * Idempotent between calls to the associated add method. Does nothing
      * before the first call to the associated add method.
      */
     public synchronized void removeCsvReporter() {
         if (this.csvReporter != null) {
             this.csvReporter.stop();
         }
         this.csvReporter = null;
     }

     /**
      * Create a {@link JmxReporter} attached to the HugeGraph Metrics registry.
      * <p>
      * If {@code domain} or {@code agentId} is null, then Metrics's uses its own
      * internal default value(s).
      * <p>
      * If {@code agentId} is non-null, then
      * {@link MBeanServerFactory#findMBeanServer(String)} must return exactly
      * one {@code MBeanServer}. The reporter will register with that server. If
      * the {@code findMBeanServer(agentId)} call returns no or multiple servers,
      * then this method logs an error and falls back on the Metrics default for
      * {@code agentId}.
      *
      * @param domain
      *            the JMX domain in which to continuously expose metrics
      * @param agentId
      *            the JMX agent ID
      */
     public synchronized void addJmxReporter(String domain, String agentId) {
         if (this.jmxReporter != null) {
             LOG.debug("Metrics JmxReporter already active");
             return;
         }

         JmxReporter.Builder builder = JmxReporter.forRegistry(getRegistry());

         if (domain != null) {
             builder.inDomain(domain);
         }

         if (agentId != null) {
             List<MBeanServer> servs =
                     MBeanServerFactory.findMBeanServer(agentId);
             if (servs != null && servs.size() == 1) {
                 builder.registerWith(servs.get(0));
             } else {
                 LOG.error("Metrics Slf4jReporter agentId {} does not " +
                           "resolve to a single MBeanServer", agentId);
             }
         }

         this.jmxReporter = builder.build();
         this.jmxReporter.start();
     }

     /**
      * Stop a {@link JmxReporter} previously created by a call to
      * {@link #addJmxReporter(String, String)} and release it for GC. Idempotent
      * between calls to the associated add method. Does nothing before the first
      * call to the associated add method.
      */
     public synchronized void removeJmxReporter() {
         if (this.jmxReporter != null) {
             this.jmxReporter.stop();
         }
         this.jmxReporter = null;
     }

     /**
      * Create a {@link Slf4jReporter} attached to the HugeGraph Metrics registry
      * <p>
      * If {@code loggerName} is null, or if it is non-null but
      * {@link LoggerFactory#getLogger(String)} returns null, then Metrics's
      * default Slf4j logger name is used instead.
      *
      * @param reportInterval
      *            time to wait between writing metrics to the Slf4j logger
      * @param loggerName
      *            the name of the Slf4j logger that receives metrics
      */
     public synchronized void addSlf4jReporter(Duration reportInterval,
                                               String loggerName) {
         if (this.slf4jReporter != null) {
             LOG.debug("Metrics Slf4jReporter already active");
             return;
         }

         Slf4jReporter.Builder builder =
                 Slf4jReporter.forRegistry(getRegistry());

         if (loggerName != null) {
             Logger slfLogger = LoggerFactory.getLogger(loggerName);
             if (slfLogger != null) {
                 builder.outputTo(slfLogger);
             } else {
                 LOG.error("Logger with name {} could not be obtained",
                           loggerName);
             }
         }

         this.slf4jReporter = builder.build();
         this.slf4jReporter.start(reportInterval.toMillis(), TimeUnit.MILLISECONDS);
     }

     /**
      * Stop a {@link Slf4jReporter} previously created by a call to
      * {@link #addSlf4jReporter(Duration, String)} and release it for GC.
      * Idempotent between calls to the associated add method. Does nothing
      * before the first call to the associated add method.
      */
     public synchronized void removeSlf4jReporter() {
         if (this.slf4jReporter != null) {
             this.slf4jReporter.stop();
         }
         this.slf4jReporter = null;
     }

     /**
      * Create a {@link GangliaReporter} attached to the HugeGraph Metrics
      * registry.
      * <p>
      * {@code groupOrHost} and {@code addressingMode} must be non-null. The
      * remaining non-primitive arguments may be null. If {@code protocol31} is
      * null, then true is assumed. Null values of {@code hostUUID} or
      * {@code spoof} are passed into the {@link GMetric} constructor, which
      * causes Ganglia to use its internal logic for generating a default UUID
      * and default reporting hostname (respectively).
      *
      * @param groupOrHost
      *            the multicast group or unicast hostname to which Ganglia
      *            events are sent
      * @param port
      *            the port to which events are sent
      * @param addressingMode
      *            whether to send events with multicast or unicast
      * @param ttl
      *            multicast ttl (ignored for unicast)
      * @param protocol31
      *            true to use Ganglia protocol version 3.1, false to use 3.0
      * @param hostUUID
      *            uuid for the host
      * @param spoof
      *            override this machine's IP/hostname as it appears on the
      *            Ganglia server
      * @param reportInterval
      *            titme to wait before sending data to the ganglia
      *            unicast host or multicast group
      * @throws IOException
      *             when a {@link GMetric} can't be instantiated using the
      *             provided arguments
      */
     public synchronized void addGangliaReporter(
            String groupOrHost, int port, UDPAddressingMode addressingMode,
            int ttl, Boolean protocol31, UUID hostUUID, String spoof,
            Duration reportInterval) throws IOException {

         Preconditions.checkNotNull(groupOrHost);
         Preconditions.checkNotNull(addressingMode);

         if (this.gangliaReporter != null) {
             LOG.debug("Metrics GangliaReporter already active");
             return;
         }

         if (protocol31 == null) {
             protocol31 = true;
         }
         GMetric ganglia = new GMetric(groupOrHost, port, addressingMode, ttl,
                                       protocol31, hostUUID, spoof);

         GangliaReporter.Builder builder =
                 GangliaReporter.forRegistry(getRegistry());

         this.gangliaReporter = builder.build(ganglia);
         this.gangliaReporter.start(reportInterval.toMillis(),
                                    TimeUnit.MILLISECONDS);

         LOG.info("Configured Ganglia Metrics reporter host={} interval={} " +
                  "port={} addrmode={} ttl={} proto31={} uuid={} spoof={}",
                  groupOrHost, reportInterval, port, addressingMode, ttl,
                  protocol31, hostUUID, spoof);
     }

     /**
      * Stop a {@link GangliaReporter} previously created by a call to
      * {@link #addGangliaReporter}
      * and release it for GC. Idempotent between calls to the associated add
      * method. Does nothing before the first call to the associated add method.
      */
     public synchronized void removeGangliaReporter() {
         if (this.gangliaReporter != null) {
             this.gangliaReporter.stop();
         }
         this.gangliaReporter = null;
     }

     /**
      * Create a {@link GraphiteReporter} attached to the HugeGraph Metrics
      * registry.
      * <p>
      * If {@code prefix} is null, then Metrics's internal default prefix is used
      * (empty string at the time this comment was written).
      *
      * @param host
      *            the host to which Graphite reports are sent
      * @param port
      *            the port to which Graphite reports are sent
      * @param prefix
      *            the optional metrics prefix
      * @param reportInterval
      *            time to wait between sending metrics to the configured
      *            Graphite host and port
      */
     public synchronized void addGraphiteReporter(String host, int port,
                                                  String prefix,
                                                  Duration reportInterval) {

         Preconditions.checkNotNull(host);

         Graphite graphite = new Graphite(new InetSocketAddress(host, port));

         GraphiteReporter.Builder builder =
                 GraphiteReporter.forRegistry(getRegistry());

         if (prefix != null) {
             builder.prefixedWith(prefix);
         }
         builder.filter(MetricFilter.ALL);

         this.graphiteReporter = builder.build(graphite);
         this.graphiteReporter.start(reportInterval.toMillis(),
                                     TimeUnit.MILLISECONDS);
         LOG.info("Configured Graphite reporter host={} interval={} " +
                  "port={} prefix={}", host, reportInterval, port, prefix);
     }

     /**
      * Stop a {@link GraphiteReporter} previously created by a call to
      * {@link #addGraphiteReporter(String, int, String, Duration)} and release
      * it for GC. Idempotent between calls to the associated add method. Does
      * nothing before the first call to the associated add method.
      */
     public synchronized void removeGraphiteReporter() {
         if (this.graphiteReporter != null) {
             this.graphiteReporter.stop();
         }
         this.graphiteReporter = null;
     }

     /**
      * Remove all HugeGraph Metrics reporters previously configured through the
      * {@code add*} methods on this class.
      */
     public synchronized void removeAllReporters() {
         removeConsoleReporter();
         removeCsvReporter();
         removeJmxReporter();
         removeSlf4jReporter();
         removeGangliaReporter();
         removeGraphiteReporter();
     }

     public Counter getCounter(String name) {
         return getRegistry().counter(name);
     }

     public Counter getCounter(String prefix, String... names) {
         return getRegistry().counter(MetricRegistry.name(prefix, names));
     }

     public Timer getTimer(String name) {
         return getRegistry().timer(name);
     }

     public Timer getTimer(String prefix, String... names) {
         return getRegistry().timer(MetricRegistry.name(prefix, names));
     }

     public Histogram getHistogram(String name) {
         return getRegistry().histogram(name);
     }

     public Histogram getHistogram(String prefix, String... names) {
         return getRegistry().histogram(MetricRegistry.name(prefix, names));
     }

     public boolean remove(String name) {
         return getRegistry().remove(name);
     }
 }
	/*
	* Copyright 2017 HugeGraph Authors
	*
	* 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 com.baidu.hugegraph.stats;

	import java.io.File;
	import java.io.IOException;
	import java.net.InetSocketAddress;
	import java.time.Duration;
	import java.util.List;
	import java.util.UUID;
	import java.util.concurrent.TimeUnit;

	import javax.management.MBeanServer;
	import javax.management.MBeanServerFactory;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import com.baidu.hugegraph.util.Log;
	import com.codahale.metrics.ConsoleReporter;
	import com.codahale.metrics.Counter;
	import com.codahale.metrics.CsvReporter;
	import com.codahale.metrics.Histogram;
	import com.codahale.metrics.JmxReporter;
	import com.codahale.metrics.MetricFilter;
	import com.codahale.metrics.MetricRegistry;
	import com.codahale.metrics.Slf4jReporter;
	import com.codahale.metrics.Timer;
	import com.codahale.metrics.ganglia.GangliaReporter;
	import com.codahale.metrics.graphite.Graphite;
	import com.codahale.metrics.graphite.GraphiteReporter;
	import com.google.common.base.Preconditions;

	import info.ganglia.gmetric4j.gmetric.GMetric;
	import info.ganglia.gmetric4j.gmetric.GMetric.UDPAddressingMode;

	/**
	* Singleton that contains and configures HugeGraph's {@code MetricRegistry}.
	*/
	public class MetricsManager {

	private static final Logger LOG = Log.logger(MetricsManager.class);

	private static final MetricsManager INSTANCE = new MetricsManager();

	private final MetricRegistry registry;
	private ConsoleReporter consoleReporter = null;
	private CsvReporter csvReporter = null;
	private JmxReporter jmxReporter = null;
	private Slf4jReporter slf4jReporter = null;
	private GangliaReporter gangliaReporter = null;
	private GraphiteReporter graphiteReporter = null;

	/**
	* Private constructor for singleton.
	*/
	private MetricsManager() {
	this.registry = new MetricRegistry();
	}

	/**
	* Return the Singleton Metrics Manager.
	*
	* @return the single {@code MetricManager}
	*/
	public static MetricsManager instance() {
	return INSTANCE;
	}

	/**
	* Return the HugeGraph Metrics registry.
	*
	* @return the single {@code MetricRegistry} used for all of HugeGraph's
	* Metrics monitoring
	*/
	public MetricRegistry getRegistry() {
	return this.registry;
	}

	/**
	* Create a {@link ConsoleReporter} attached to the HugeGraph Metrics
	* registry.
	*
	* @param reportInterval
	* time to wait between dumping metrics to the console
	*/
	public synchronized void addConsoleReporter(Duration reportInterval) {
	if (this.consoleReporter != null) {
	LOG.debug("Metrics ConsoleReporter already active");
	return;
	}

	this.consoleReporter = ConsoleReporter.forRegistry(getRegistry()).build();
	this.consoleReporter.start(reportInterval.toMillis(), TimeUnit.MILLISECONDS);
	}

	/**
	* Stop a {@link ConsoleReporter} previously created by a call to
	* {@link #addConsoleReporter(Duration)} and release it for GC. Idempotent
	* between calls to the associated add method. Does nothing before the first
	* call to the associated add method.
	*/
	public synchronized void removeConsoleReporter() {
	if (this.consoleReporter != null) {
	this.consoleReporter.stop();
	}
	this.consoleReporter = null;
	}

	/**
	* Create a {@link CsvReporter} attached to the HugeGraph Metrics registry.
	* <p>
	* The {@code output} argument must be non-null but need not exist. If it
	* doesn't already exist, this method attempts to create it by calling
	* {@link File#mkdirs()}.
	*
	* @param reportInterval
	* time to wait between dumping metrics to CSV files in
	* the configured directory
	* @param output
	* the path to a directory into which Metrics will periodically
	* write CSV data
	*/
	public synchronized void addCsvReporter(Duration reportInterval,
	String output) {

	File outputDir = new File(output);

	if (this.csvReporter != null) {
	LOG.debug("Metrics CsvReporter already active");
	return;
	}

	if (!outputDir.exists()) {
	if (!outputDir.mkdirs()) {
	LOG.warn("Failed to create CSV metrics dir {}", outputDir);
	}
	}

	this.csvReporter = CsvReporter.forRegistry(getRegistry()).build(outputDir);
	this.csvReporter.start(reportInterval.toMillis(), TimeUnit.MILLISECONDS);
	}

	/**
	* Stop a {@link CsvReporter} previously created by a call to
	* {@link #addCsvReporter(Duration, String)} and release it for GC.
	* Idempotent between calls to the associated add method. Does nothing
	* before the first call to the associated add method.
	*/
	public synchronized void removeCsvReporter() {
	if (this.csvReporter != null) {
	this.csvReporter.stop();
	}
	this.csvReporter = null;
	}

	/**
	* Create a {@link JmxReporter} attached to the HugeGraph Metrics registry.
	* <p>
	* If {@code domain} or {@code agentId} is null, then Metrics's uses its own
	* internal default value(s).
	* <p>
	* If {@code agentId} is non-null, then
	* {@link MBeanServerFactory#findMBeanServer(String)} must return exactly
	* one {@code MBeanServer}. The reporter will register with that server. If
	* the {@code findMBeanServer(agentId)} call returns no or multiple servers,
	* then this method logs an error and falls back on the Metrics default for
	* {@code agentId}.
	*
	* @param domain
	* the JMX domain in which to continuously expose metrics
	* @param agentId
	* the JMX agent ID
	*/
	public synchronized void addJmxReporter(String domain, String agentId) {
	if (this.jmxReporter != null) {
	LOG.debug("Metrics JmxReporter already active");
	return;
	}

	JmxReporter.Builder builder = JmxReporter.forRegistry(getRegistry());

	if (domain != null) {
	builder.inDomain(domain);
	}

	if (agentId != null) {
	List<MBeanServer> servs =
	MBeanServerFactory.findMBeanServer(agentId);
	if (servs != null && servs.size() == 1) {
	builder.registerWith(servs.get(0));
	} else {
	LOG.error("Metrics Slf4jReporter agentId {} does not " +
	"resolve to a single MBeanServer", agentId);
	}
	}

	this.jmxReporter = builder.build();
	this.jmxReporter.start();
	}

	/**
	* Stop a {@link JmxReporter} previously created by a call to
	* {@link #addJmxReporter(String, String)} and release it for GC. Idempotent
	* between calls to the associated add method. Does nothing before the first
	* call to the associated add method.
	*/
	public synchronized void removeJmxReporter() {
	if (this.jmxReporter != null) {
	this.jmxReporter.stop();
	}
	this.jmxReporter = null;
	}

	/**
	* Create a {@link Slf4jReporter} attached to the HugeGraph Metrics registry
	* <p>
	* If {@code loggerName} is null, or if it is non-null but
	* {@link LoggerFactory#getLogger(String)} returns null, then Metrics's
	* default Slf4j logger name is used instead.
	*
	* @param reportInterval
	* time to wait between writing metrics to the Slf4j logger
	* @param loggerName
	* the name of the Slf4j logger that receives metrics
	*/
	public synchronized void addSlf4jReporter(Duration reportInterval,
	String loggerName) {
	if (this.slf4jReporter != null) {
	LOG.debug("Metrics Slf4jReporter already active");
	return;
	}

	Slf4jReporter.Builder builder =
	Slf4jReporter.forRegistry(getRegistry());

	if (loggerName != null) {
	Logger slfLogger = LoggerFactory.getLogger(loggerName);
	if (slfLogger != null) {
	builder.outputTo(slfLogger);
	} else {
	LOG.error("Logger with name {} could not be obtained",
	loggerName);
	}
	}

	this.slf4jReporter = builder.build();
	this.slf4jReporter.start(reportInterval.toMillis(), TimeUnit.MILLISECONDS);
	}

	/**
	* Stop a {@link Slf4jReporter} previously created by a call to
	* {@link #addSlf4jReporter(Duration, String)} and release it for GC.
	* Idempotent between calls to the associated add method. Does nothing
	* before the first call to the associated add method.
	*/
	public synchronized void removeSlf4jReporter() {
	if (this.slf4jReporter != null) {
	this.slf4jReporter.stop();
	}
	this.slf4jReporter = null;
	}

	/**
	* Create a {@link GangliaReporter} attached to the HugeGraph Metrics
	* registry.
	* <p>
	* {@code groupOrHost} and {@code addressingMode} must be non-null. The
	* remaining non-primitive arguments may be null. If {@code protocol31} is
	* null, then true is assumed. Null values of {@code hostUUID} or
	* {@code spoof} are passed into the {@link GMetric} constructor, which
	* causes Ganglia to use its internal logic for generating a default UUID
	* and default reporting hostname (respectively).
	*
	* @param groupOrHost
	* the multicast group or unicast hostname to which Ganglia
	* events are sent
	* @param port
	* the port to which events are sent
	* @param addressingMode
	* whether to send events with multicast or unicast
	* @param ttl
	* multicast ttl (ignored for unicast)
	* @param protocol31
	* true to use Ganglia protocol version 3.1, false to use 3.0
	* @param hostUUID
	* uuid for the host
	* @param spoof
	* override this machine's IP/hostname as it appears on the
	* Ganglia server
	* @param reportInterval
	* titme to wait before sending data to the ganglia
	* unicast host or multicast group
	* @throws IOException
	* when a {@link GMetric} can't be instantiated using the
	* provided arguments
	*/
	public synchronized void addGangliaReporter(
	String groupOrHost, int port, UDPAddressingMode addressingMode,
	int ttl, Boolean protocol31, UUID hostUUID, String spoof,
	Duration reportInterval) throws IOException {

	Preconditions.checkNotNull(groupOrHost);
	Preconditions.checkNotNull(addressingMode);

	if (this.gangliaReporter != null) {
	LOG.debug("Metrics GangliaReporter already active");
	return;
	}

	if (protocol31 == null) {
	protocol31 = true;
	}
	GMetric ganglia = new GMetric(groupOrHost, port, addressingMode, ttl,
	protocol31, hostUUID, spoof);

	GangliaReporter.Builder builder =
	GangliaReporter.forRegistry(getRegistry());

	this.gangliaReporter = builder.build(ganglia);
	this.gangliaReporter.start(reportInterval.toMillis(),
	TimeUnit.MILLISECONDS);

	LOG.info("Configured Ganglia Metrics reporter host={} interval={} " +
	"port={} addrmode={} ttl={} proto31={} uuid={} spoof={}",
	groupOrHost, reportInterval, port, addressingMode, ttl,
	protocol31, hostUUID, spoof);
	}

	/**
	* Stop a {@link GangliaReporter} previously created by a call to
	* {@link #addGangliaReporter}
	* and release it for GC. Idempotent between calls to the associated add
	* method. Does nothing before the first call to the associated add method.
	*/
	public synchronized void removeGangliaReporter() {
	if (this.gangliaReporter != null) {
	this.gangliaReporter.stop();
	}
	this.gangliaReporter = null;
	}

	/**
	* Create a {@link GraphiteReporter} attached to the HugeGraph Metrics
	* registry.
	* <p>
	* If {@code prefix} is null, then Metrics's internal default prefix is used
	* (empty string at the time this comment was written).
	*
	* @param host
	* the host to which Graphite reports are sent
	* @param port
	* the port to which Graphite reports are sent
	* @param prefix
	* the optional metrics prefix
	* @param reportInterval
	* time to wait between sending metrics to the configured
	* Graphite host and port
	*/
	public synchronized void addGraphiteReporter(String host, int port,
	String prefix,
	Duration reportInterval) {

	Preconditions.checkNotNull(host);

	Graphite graphite = new Graphite(new InetSocketAddress(host, port));

	GraphiteReporter.Builder builder =
	GraphiteReporter.forRegistry(getRegistry());

	if (prefix != null) {
	builder.prefixedWith(prefix);
	}
	builder.filter(MetricFilter.ALL);

	this.graphiteReporter = builder.build(graphite);
	this.graphiteReporter.start(reportInterval.toMillis(),
	TimeUnit.MILLISECONDS);
	LOG.info("Configured Graphite reporter host={} interval={} " +
	"port={} prefix={}", host, reportInterval, port, prefix);
	}

	/**
	* Stop a {@link GraphiteReporter} previously created by a call to
	* {@link #addGraphiteReporter(String, int, String, Duration)} and release
	* it for GC. Idempotent between calls to the associated add method. Does
	* nothing before the first call to the associated add method.
	*/
	public synchronized void removeGraphiteReporter() {
	if (this.graphiteReporter != null) {
	this.graphiteReporter.stop();
	}
	this.graphiteReporter = null;
	}

	/**
	* Remove all HugeGraph Metrics reporters previously configured through the
	* {@code add*} methods on this class.
	*/
	public synchronized void removeAllReporters() {
	removeConsoleReporter();
	removeCsvReporter();
	removeJmxReporter();
	removeSlf4jReporter();
	removeGangliaReporter();
	removeGraphiteReporter();
	}

	public Counter getCounter(String name) {
	return getRegistry().counter(name);
	}

	public Counter getCounter(String prefix, String... names) {
	return getRegistry().counter(MetricRegistry.name(prefix, names));
	}

	public Timer getTimer(String name) {
	return getRegistry().timer(name);
	}

	public Timer getTimer(String prefix, String... names) {
	return getRegistry().timer(MetricRegistry.name(prefix, names));
	}

	public Histogram getHistogram(String name) {
	return getRegistry().histogram(name);
	}

	public Histogram getHistogram(String prefix, String... names) {
	return getRegistry().histogram(MetricRegistry.name(prefix, names));
	}

	public boolean remove(String name) {
	return getRegistry().remove(name);
	}
	}