org.apache.slider.server.appmaster.management.MetricsBindingService.java Source code

Introduction

Here is the source code for org.apache.slider.server.appmaster.management.MetricsBindingService.java

Source

/*
 * 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.slider.server.appmaster.management;

import com.codahale.metrics.JmxReporter;
import com.codahale.metrics.Metric;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.MetricSet;
import com.codahale.metrics.ScheduledReporter;
import com.codahale.metrics.Slf4jReporter;
import com.google.common.base.Preconditions;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.service.CompositeService;
import org.apache.slider.server.services.workflow.ClosingService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * YARN service which hooks up Codahale metrics to 
 * JMX, and, if enabled Ganglia and/or an SLF4J log.
 */
public class MetricsBindingService extends CompositeService implements MetricsKeys {
    protected static final Logger log = LoggerFactory.getLogger(MetricsBindingService.class);
    private final MetricRegistry metrics;

    private String reportingDetails = "not started";

    public MetricsBindingService(String name, MetricRegistry metrics) {
        super(name);
        Preconditions.checkArgument(metrics != null, "Null metrics");
        this.metrics = metrics;
    }

    /**
     * Instantiate...create a metric registry in the process
     * @param name service name
     */
    public MetricsBindingService(String name) {
        this(name, new MetricRegistry());
    }

    /**
     * Accessor for the metrics instance
     * @return the metrics
     */
    public MetricRegistry getMetrics() {
        return metrics;
    }

    @Override
    protected void serviceStart() throws Exception {
        super.serviceStart();

        StringBuilder summary = new StringBuilder();
        Configuration conf = getConfig();

        summary.append("Reporting to JMX");
        // always start the JMX binding
        JmxReporter jmxReporter;
        jmxReporter = JmxReporter.forRegistry(metrics).build();
        jmxReporter.start();
        addService(new ClosingService<>(jmxReporter));

        // Ganglia
        if (conf.getBoolean(METRICS_GANGLIA_ENABLED, false)) {
            log.warn("Ganglia integration is not implemented");
            /*
                  // This is all disabled due to transitive dependencies on an LGPL library
                  com.codahale.metrics.ganglia.GangliaReporter gangliaReporter;
                  String host = conf.getTrimmed(METRICS_GANGLIA_HOST, "");
                  int port = conf.getInt(METRICS_GANGLIA_PORT, DEFAULT_GANGLIA_PORT);
                  int interval = conf.getInt(METRICS_GANGLIA_REPORT_INTERVAL, 60);
                  int ttl = 1;
                  info.ganglia.gmetric4j.gmetric.GMetric.UDPAddressingMode
                      mcast = info.ganglia.gmetric4j.gmetric.GMetric.UDPAddressingMode.getModeForAddress(host);
                  boolean ganglia31 = conf.getBoolean(METRICS_GANGLIA_VERSION_31, true);
                
                  final info.ganglia.gmetric4j.gmetric.GMetric ganglia =
                      new info.ganglia.gmetric4j.gmetric.GMetric(
                          host,
                          port,
                          mcast,
                          ttl,
                          ganglia31);
                  gangliaReporter = com.codahale.metrics.ganglia.GangliaReporter.forRegistry(metrics)
                                   .convertRatesTo(TimeUnit.SECONDS)
                                   .convertDurationsTo(
                                       TimeUnit.MILLISECONDS)
                                   .build(ganglia);
                  gangliaReporter.start(interval, TimeUnit.SECONDS);
                  addService(new ClosingService<ScheduledReporter>(gangliaReporter));
                  summary.append(String.format(", Ganglia at %s:%d interval=%d",
                      host, port, interval));
                  */
        }

        // Logging
        if (conf.getBoolean(METRICS_LOGGING_ENABLED, false)) {
            ScheduledReporter reporter;
            String logName = conf.getTrimmed(METRICS_LOGGING_LOG, METRICS_DEFAULT_LOG);
            int interval = conf.getInt(METRICS_LOGGING_LOG_INTERVAL, METRICS_DEFAULT_LOG_INTERVAL);
            reporter = Slf4jReporter.forRegistry(metrics).convertRatesTo(TimeUnit.SECONDS)
                    .outputTo(LoggerFactory.getLogger(logName)).convertDurationsTo(TimeUnit.MILLISECONDS).build();
            reporter.start(interval, TimeUnit.MINUTES);
            addService(new ClosingService<>(reporter));
            summary.append(String.format(", SLF4J to log %s interval=%d", logName, interval));
        }
        reportingDetails = summary.toString();
        log.info(reportingDetails);
    }

    @Override
    public String toString() {
        return super.toString() + " " + reportingDetails;
    }

}