Java tutorial
/* * Copyright 2010-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file 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.amazonaws.metrics.internal.cloudwatch; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.DaemonThreadCount; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.DeadLockThreadCount; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.FreeMemory; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.OpenFileDescriptorCount; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.PeakThreadCount; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.SpareFileDescriptorCount; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.SpareMemory; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.ThreadCount; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.TotalMemory; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.TotalStartedThreadCount; import static com.amazonaws.metrics.internal.cloudwatch.MachineMetric.UsedMemory; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Set; import org.apache.commons.logging.LogFactory; import com.amazonaws.jmx.spi.JmxInfoProvider; import com.amazonaws.metrics.AwsSdkMetrics; import com.amazonaws.metrics.MetricType; import com.amazonaws.services.cloudwatch.model.Dimension; import com.amazonaws.services.cloudwatch.model.MetricDatum; import com.amazonaws.services.cloudwatch.model.StandardUnit; class MachineMetricFactory { private static final List<MachineMetric> memoryMetrics = Arrays.asList(TotalMemory, FreeMemory, UsedMemory, SpareMemory); private static final List<MachineMetric> threadMetrics = Arrays.asList(ThreadCount, DeadLockThreadCount, DaemonThreadCount, PeakThreadCount, TotalStartedThreadCount); private static final List<MachineMetric> fdMetrics = Arrays.asList(OpenFileDescriptorCount, SpareFileDescriptorCount); private final JmxInfoProvider jmxInfoProvider = JmxInfoProvider.Factory.getJmxInfoProvider(); /** * Add the given list of metrics and corresponding values specified in * "metricValues" to the given list of metric datum. * * @param list * list of metric data * @param metricValues * list of metrics and their corresponding values */ private void addMetrics(List<MetricDatum> list, MetricValues metricValues, StandardUnit unit) { List<MachineMetric> machineMetrics = metricValues.getMetrics(); List<Long> values = metricValues.getValues(); for (int i = 0; i < machineMetrics.size(); i++) { MachineMetric metric = machineMetrics.get(i); long val = values.get(i).longValue(); // skip zero values in some cases if (val != 0 || metric.includeZeroValue()) { MetricDatum datum = new MetricDatum().withMetricName(metric.getMetricName()) .withDimensions( new Dimension().withName(metric.getDimensionName()).withValue(metric.name())) .withUnit(unit).withValue((double) val); list.add(datum); } } } /** * Returns the set of custom machine metrics specified in the SDK metrics * registry; or an empty set if there is none. Note any machine metrics * found in the registry must have been custom specified, as the default * behavior is to include all machine metrics when enabled. * * @return a non-null set of machine metrics. An empty set means no custom * machine metrics have been specified. */ private Set<MachineMetric> customMachineMetrics() { Set<MachineMetric> customized = new HashSet<MachineMetric>(); for (MetricType m : AwsSdkMetrics.getPredefinedMetrics()) { if (m instanceof MachineMetric) customized.add((MachineMetric) m); } return customized; } /** * Returns a subset of the given list of metrics in "defaults" and the * corresponding value of each returned metric in the subset. Note if the * custom set is empty, the full set of default machine metrics and values * will be returned. (In particular, as in set theory, a set is a subset of * itself.) * * @param customSet * custom machine metrics specified in the SDK metrics registry * @param defaults * the given default list of metrics * @param values * corresponding values of each metric in "defaults" */ private MetricValues metricValues(Set<MachineMetric> customSet, List<MachineMetric> defaults, List<Long> values) { List<MachineMetric> actualMetrics = defaults; List<Long> actualValues = values; if (customSet.size() > 0) { // custom set of machine metrics specified actualMetrics = new ArrayList<MachineMetric>(); actualValues = new ArrayList<Long>(); for (int i = 0; i < defaults.size(); i++) { MachineMetric mm = defaults.get(i); if (customSet.contains(mm)) { actualMetrics.add(mm); actualValues.add(values.get(i)); } } } return new MetricValues(actualMetrics, actualValues); } List<MetricDatum> generateMetrics() { if (AwsSdkMetrics.isMachineMetricExcluded()) return Collections.emptyList(); Set<MachineMetric> customSet = customMachineMetrics(); List<MetricDatum> targetList = new ArrayList<MetricDatum>(MachineMetric.values().length); // Memory usage addMemoryMetrics(targetList, customSet); // Thread related counts try { addThreadMetrics(targetList, customSet); } catch (Throwable t) { LogFactory.getLog(getClass()).debug("Ignoring thread metrics", t); } // File descriptor usage try { addFileDescriptorMetrics(targetList, customSet); } catch (Throwable t) { LogFactory.getLog(getClass()).debug("Ignoring file descriptor metrics", t); } return targetList; } private void addMemoryMetrics(List<MetricDatum> targetList, Set<MachineMetric> customSet) { Runtime rt = Runtime.getRuntime(); long totalMem = rt.totalMemory(); long freeMem = rt.freeMemory(); long usedMem = totalMem - freeMem; long spareMem = rt.maxMemory() - usedMem; List<Long> values = Arrays.asList(totalMem, freeMem, usedMem, spareMem); MetricValues metricValues = memoryMetricValues(customSet, values); addMetrics(targetList, metricValues, StandardUnit.Bytes); } private void addFileDescriptorMetrics(List<MetricDatum> targetList, Set<MachineMetric> customSet) { JmxInfoProvider provider = JmxInfoProvider.Factory.getJmxInfoProvider(); long[] fdInfo = provider.getFileDecriptorInfo(); if (fdInfo != null) { long openFdCount = fdInfo[0]; long maxFdCount = fdInfo[1]; List<Long> values = Arrays.asList(openFdCount, maxFdCount - openFdCount); MetricValues metricValues = fdMetricValues(customSet, values); addMetrics(targetList, metricValues, StandardUnit.Count); } } private void addThreadMetrics(List<MetricDatum> targetList, Set<MachineMetric> customSet) { long threadCount = jmxInfoProvider.getThreadCount(); long[] ids = jmxInfoProvider.findDeadlockedThreads(); long deadLockThreadCount = ids == null ? 0 : ids.length; long daemonThreadCount = jmxInfoProvider.getDaemonThreadCount(); long peakThreadCount = jmxInfoProvider.getPeakThreadCount(); long totalStartedThreadCount = jmxInfoProvider.getTotalStartedThreadCount(); List<Long> values = Arrays.asList(threadCount, deadLockThreadCount, daemonThreadCount, peakThreadCount, totalStartedThreadCount); MetricValues metricValues = threadMetricValues(customSet, values); addMetrics(targetList, metricValues, StandardUnit.Count); } /** * Returns the set of memory metrics and the corresponding values based on * the default and the customized set of metrics, if any. * * @param customSet * a non-null customized set of metrics * @param values * a non-null list of values corresponding to the list of default * memory metrics */ private MetricValues memoryMetricValues(Set<MachineMetric> customSet, List<Long> values) { return metricValues(customSet, MachineMetricFactory.memoryMetrics, values); } /** * Returns the set of file-descriptor metrics and the corresponding values based on * the default and the customized set of metrics, if any. * * @param customSet * a non-null customized set of metrics * @param values * a non-null list of values corresponding to the list of default * file-descriptor metrics */ private MetricValues fdMetricValues(Set<MachineMetric> customSet, List<Long> values) { return metricValues(customSet, MachineMetricFactory.fdMetrics, values); } /** * Returns the set of thread metrics and the corresponding values based on * the default and the customized set of metrics, if any. * * @param customSet * a non-null customized set of metrics * @param values * a non-null list of values corresponding to the list of default * thread metrics */ private MetricValues threadMetricValues(Set<MachineMetric> customSet, List<Long> values) { return metricValues(customSet, MachineMetricFactory.threadMetrics, values); } // Used to get around the limitation of Java returning at most a single value private static class MetricValues { private final List<MachineMetric> metrics; private final List<Long> values; MetricValues(List<MachineMetric> metrics, List<Long> values) { this.metrics = metrics; this.values = values; } List<MachineMetric> getMetrics() { return metrics; } List<Long> getValues() { return values; } } }