Java tutorial
/* * 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.tinkerpop.gremlin.server.util; import com.codahale.metrics.ConsoleReporter; import com.codahale.metrics.Counter; import com.codahale.metrics.CsvReporter; import com.codahale.metrics.Gauge; import com.codahale.metrics.Histogram; import com.codahale.metrics.JmxReporter; import com.codahale.metrics.Meter; 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 info.ganglia.gmetric4j.gmetric.GMetric; import org.apache.commons.lang3.ArrayUtils; import org.apache.tinkerpop.gremlin.groovy.jsr223.GremlinGroovyScriptEngine; import org.apache.tinkerpop.gremlin.jsr223.GremlinScriptEngine; import org.apache.tinkerpop.gremlin.server.GremlinServer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.management.MBeanServer; import javax.management.MBeanServerFactory; import java.io.File; import java.io.IOException; import java.net.InetSocketAddress; import java.util.List; import java.util.Optional; import java.util.UUID; import java.util.concurrent.TimeUnit; /** * Singleton that contains and configures Gremlin Server's {@code MetricRegistry}. Borrowed from Titan's approach to * managing Metrics. * * @author Stephen Mallette (http://stephen.genoprime.com) */ public enum MetricManager { INSTANCE; private static final Logger log = LoggerFactory.getLogger(MetricManager.class); private final MetricRegistry registry = new MetricRegistry(); private ConsoleReporter consoleReporter = null; private CsvReporter csvReporter = null; private JmxReporter jmxReporter = null; private Slf4jReporter slf4jReporter = null; private GangliaReporter gangliaReporter = null; private GraphiteReporter graphiteReporter = null; /** * Return the {@code MetricsRegistry}. * * @return the single {@code MetricRegistry} used for all of monitoring */ public MetricRegistry getRegistry() { return registry; } /** * Create a {@link ConsoleReporter} attached to the {@code MetricsRegistry}. * * @param reportIntervalInMS milliseconds to wait between dumping metrics to the console */ public synchronized void addConsoleReporter(final long reportIntervalInMS) { if (null != consoleReporter) { log.debug("Metrics ConsoleReporter already active; not creating another"); return; } consoleReporter = ConsoleReporter.forRegistry(getRegistry()).build(); consoleReporter.start(reportIntervalInMS, TimeUnit.MILLISECONDS); log.info("Configured Metrics ConsoleReporter configured with report interval={}ms", reportIntervalInMS); } /** * Stop a {@link ConsoleReporter} previously created by a call to * {@link #addConsoleReporter(long)} 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 (null != consoleReporter) consoleReporter.stop(); consoleReporter = null; } /** * Create a {@link CsvReporter} attached to the {@code MetricsRegistry}. * <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 reportIntervalInMS milliseconds 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(final long reportIntervalInMS, final String output) { File outputDir = new File(output); if (null != csvReporter) { log.debug("Metrics CsvReporter already active; not creating another"); return; } if (!outputDir.exists()) { if (!outputDir.mkdirs()) { log.warn("Failed to create CSV metrics dir {}", outputDir); } } csvReporter = CsvReporter.forRegistry(getRegistry()).build(outputDir); csvReporter.start(reportIntervalInMS, TimeUnit.MILLISECONDS); log.info("Configured Metrics CsvReporter configured with report interval={}ms to fileName={}", reportIntervalInMS, output); } /** * Stop a {@link CsvReporter} previously created by a call to * {@link #addCsvReporter(long, 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 (null != csvReporter) csvReporter.stop(); csvReporter = null; } /** * Create a {@link JmxReporter} attached to the {@code MetricsRegistry}. * <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 * MBeanServerFactory#findMBeanServer(agentId) 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(final String domain, final String agentId) { if (null != jmxReporter) { log.debug("Metrics JmxReporter already active; not creating another"); return; } JmxReporter.Builder b = JmxReporter.forRegistry(getRegistry()); if (null != domain) { b.inDomain(domain); } if (null != agentId) { List<MBeanServer> servs = MBeanServerFactory.findMBeanServer(agentId); if (null != servs && 1 == servs.size()) { b.registerWith(servs.get(0)); } else { log.error("Metrics Slf4jReporter agentId {} does not resolve to a single MBeanServer", agentId); } } jmxReporter = b.build(); jmxReporter.start(); log.info("Configured Metrics JmxReporter configured with domain={} and agentId={}", Optional.ofNullable(domain).orElse(""), Optional.ofNullable(agentId).orElse("")); } /** * 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 (null != jmxReporter) jmxReporter.stop(); jmxReporter = null; } /** * Create a {@link Slf4jReporter} attached to the {@code MetricsRegistry}. * <p/> * If {@code loggerName} is null, or if it is non-null but * LoggerFactory.getLogger(loggerName) returns null, then Metrics's * default Slf4j logger name is used instead. * * @param reportIntervalInMS milliseconds to wait between writing metrics to the Slf4j * logger * @param loggerName the name of the Slf4j logger that receives metrics */ public synchronized void addSlf4jReporter(final long reportIntervalInMS, final String loggerName) { if (null != slf4jReporter) { log.debug("Metrics Slf4jReporter already active; not creating another"); return; } Slf4jReporter.Builder b = Slf4jReporter.forRegistry(getRegistry()); if (null != loggerName) { Logger l = LoggerFactory.getLogger(loggerName); if (null != l) { b.outputTo(l); } else { log.error("Logger with name {} could not be obtained", loggerName); } } slf4jReporter = b.build(); slf4jReporter.start(reportIntervalInMS, TimeUnit.MILLISECONDS); log.info("Configured Metrics Slf4jReporter configured with interval={}ms and loggerName={}", reportIntervalInMS, loggerName); } /** * Stop a {@link Slf4jReporter} previously created by a call to * {@link #addSlf4jReporter(long, 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 (null != slf4jReporter) slf4jReporter.stop(); slf4jReporter = null; } /** * Create a {@link GangliaReporter} attached to the {@code MetricsRegistry}. * <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 reportIntervalInMS milliseconds 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(final String groupOrHost, final int port, final GMetric.UDPAddressingMode addressingMode, final int ttl, final Boolean protocol31, final UUID hostUUID, final String spoof, final long reportIntervalInMS) throws IOException { if (null == groupOrHost || groupOrHost.isEmpty()) throw new IllegalArgumentException("groupOrHost cannot be null or empty"); if (null == addressingMode) throw new IllegalArgumentException("addressing mode cannot be null"); if (null != gangliaReporter) { log.debug("Metrics GangliaReporter already active; not creating another"); return; } final boolean protocol = null == protocol31 ? true : protocol31; GMetric ganglia = new GMetric(groupOrHost, port, addressingMode, ttl, protocol, hostUUID, spoof); GangliaReporter.Builder b = GangliaReporter.forRegistry(getRegistry()); gangliaReporter = b.build(ganglia); gangliaReporter.start(reportIntervalInMS, TimeUnit.MILLISECONDS); log.info( "Configured Ganglia Metrics reporter host={} interval={}ms port={} addrmode={} ttl={} proto31={} uuid={} spoof={}", new Object[] { groupOrHost, reportIntervalInMS, port, addressingMode, ttl, protocol31, hostUUID, spoof }); } /** * Stop a {@link GangliaReporter} previously created by a call to * addGangliaReporter(String, int, GMetric.UDPAddressingMode, int, Boolean, UUID, long) * 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 (null != gangliaReporter) gangliaReporter.stop(); gangliaReporter = null; } /** * Create a {@link GraphiteReporter} attached to the {@code MetricsRegistry}. * <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 reportIntervalInMS milliseconds to wait between sending metrics to the configured * Graphite host and port */ public synchronized void addGraphiteReporter(final String host, final int port, final String prefix, final long reportIntervalInMS) { if (host == null || host.isEmpty()) throw new IllegalArgumentException("Host cannot be null or empty"); Graphite graphite = new Graphite(new InetSocketAddress(host, port)); GraphiteReporter.Builder b = GraphiteReporter.forRegistry(getRegistry()); if (null != prefix) b.prefixedWith(prefix); b.filter(MetricFilter.ALL); graphiteReporter = b.build(graphite); graphiteReporter.start(reportIntervalInMS, TimeUnit.MILLISECONDS); log.info("Configured Graphite reporter host={} interval={}ms port={} prefix={}", new Object[] { host, reportIntervalInMS, port, prefix }); } /** * Stop a {@link GraphiteReporter} previously created by a call to * {@link #addGraphiteReporter(String, int, String, long)} 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 (null != graphiteReporter) graphiteReporter.stop(); graphiteReporter = null; } /** * Remove all reporters previously configured through the {@code add*} methods on this class. */ public synchronized void removeAllReporters() { removeConsoleReporter(); removeCsvReporter(); removeJmxReporter(); removeSlf4jReporter(); removeGangliaReporter(); removeGraphiteReporter(); } public synchronized void removeAllMetrics() { getRegistry().removeMatching((s, metric) -> true); } public Counter getCounter(final String name) { return getRegistry().counter(name); } public Counter getCounter(final String prefix, final String... names) { return getRegistry().counter(MetricRegistry.name(prefix, names)); } public <T> Gauge<T> getGuage(final Gauge<T> gauge, final String name) { return getRegistry().register(name, gauge); } public <T> Gauge<T> getGuage(final Gauge<T> gauge, final String prefix, final String... names) { return getRegistry().register(MetricRegistry.name(prefix, names), gauge); } public Meter getMeter(final String name) { return getRegistry().meter(name); } public Meter getMeter(final String prefix, final String... names) { return getRegistry().meter(MetricRegistry.name(prefix, names)); } public Timer getTimer(final String name) { return getRegistry().timer(name); } public Timer getTimer(final String prefix, final String... names) { return getRegistry().timer(MetricRegistry.name(prefix, names)); } public Histogram getHistogram(final String name) { return getRegistry().histogram(name); } public Histogram getHistogram(final String prefix, final String... names) { return getRegistry().histogram(MetricRegistry.name(prefix, names)); } /** * Registers metrics from a {@link GremlinScriptEngine}. At this point, this only works for the * {@link GremlinGroovyScriptEngine} as it is the only one that collects metrics at this point. As the * {@link GremlinScriptEngine} implementations achieve greater parity these metrics will get expanded. */ public void registerGremlinScriptEngineMetrics(final GremlinScriptEngine engine, final String... prefix) { if (engine instanceof GremlinGroovyScriptEngine) { final GremlinGroovyScriptEngine gremlinGroovyScriptEngine = (GremlinGroovyScriptEngine) engine; getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "long-run-compilation-count")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheLongRunCompilationCount); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "estimated-size")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheEstimatedSize); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "average-load-penalty")), (Gauge<Double>) gremlinGroovyScriptEngine::getClassCacheAverageLoadPenalty); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "eviction-count")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheEvictionCount); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "eviction-weight")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheEvictionWeight); getRegistry().register(MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "hit-count")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheHitCount); getRegistry().register(MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "hit-rate")), (Gauge<Double>) gremlinGroovyScriptEngine::getClassCacheHitRate); getRegistry().register(MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "load-count")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheLoadCount); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "load-failure-count")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheLoadFailureCount); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "load-failure-rate")), (Gauge<Double>) gremlinGroovyScriptEngine::getClassCacheLoadFailureRate); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "load-success-count")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheLoadSuccessCount); getRegistry().register(MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "miss-count")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheMissCount); getRegistry().register(MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "miss-rate")), (Gauge<Double>) gremlinGroovyScriptEngine::getClassCacheMissRate); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "request-count")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheRequestCount); getRegistry().register( MetricRegistry.name(GremlinServer.class, ArrayUtils.add(prefix, "total-load-time")), (Gauge<Long>) gremlinGroovyScriptEngine::getClassCacheTotalLoadTime); } } }