com.codahale.metrics.Counting Java Examples

private void processCounter(final String metricName, final Counting counter, final List<MetricDatum> metricData) {
    long currentCount = counter.getCount();
    Long lastCount = lastPolledCounts.get(counter);
    lastPolledCounts.put(counter, currentCount);

    if (lastCount == null) {
        lastCount = 0L;
    }

    final long reportValue;
    if (builder.withReportRawCountValue) {
        reportValue = currentCount;
    } else {
        // Only submit metrics that have changed - let's save some money!
        reportValue = currentCount - lastCount;
    }

    stageMetricDatum(true, metricName, reportValue, StandardUnit.COUNT, DIMENSION_COUNT, metricData);
}
 

void reportCounter(Map.Entry<String, ? extends Counting> entry, String typeDimValue, List<MetricDatum> data) {
    Counting metric = entry.getValue();
    final long diff = diffLast(metric);
    if (diff == 0) {
        // Don't submit metrics that have not changed. No reason to keep these alive. Also saves on CloudWatch
        // costs.
        return;
    }

    DemuxedKey key = new DemuxedKey(appendGlobalDimensions(entry.getKey()));
    Iterables.addAll(data, key.newDatums(typeDimName, typeDimValue, new Function<MetricDatum, MetricDatum>() {
        @Override
        public MetricDatum apply(MetricDatum datum) {
            return datum.withValue((double) diff).withUnit(StandardUnit.Count);
        }
    }));
}
 

static <X extends Sampling & Counting> SamplingCounting adaptSamplingCounting(final X metric) {
    return new SamplingCounting() {
        @Override
        public long getCount() {
            return metric.getCount();
        }

        @Override
        public Iterable<Interval> getIntervals() {
            final Snapshot snapshot = metric.getSnapshot();

            return Interval.asIntervals(Interval.Quantile.STANDARD_PERCENTILES, q -> (float) snapshot.getValue(q.value));
        }
    };
}
 

/**
 * Timers and Histograms can be optimised if access to the "raw" {@link com.codahale.metrics.Metric} is available (in-process only).
 * This function tries to access the given {@link NamedObject}'s raw Metric, and adapt it to a {@link SamplingCounting}, failing back to adapting
 * the JMX proxy object to a {@link SamplingCounting}.
 */
private static <RawT extends Sampling & Counting, MBeanT> NamedObject<SamplingCounting> mBeanAsSamplingCounting(final NamedObject<?> mBean, final Function<MBeanT, SamplingCounting> mBeanAdapterFunction) {
    try {
        return CassandraMetricsUtilities.<RawT>metricForMBean(mBean).map((n, o) -> adaptSamplingCounting(o));

    } catch (final Exception e) {
        return mBean.<MBeanT>cast().map((n, o) -> mBeanAdapterFunction.apply(o));
    }
}
 

private void updateFromMetrics(Map<String, ? extends Counting> metrics) {
    metrics.forEach((key, metric) -> {
        long count = metric.getCount();

        onMetricCount(key, (int) count);
    });
}
 

private Set<String> updatedMetrics(MetricRegistry registry) {
    Map<String, Meter> meterMap = registry.getMeters((name, metric) -> {
        if (!excludedNames.contains(name)) {
            if (metric instanceof Counting) {
                return ((Counting) metric).getCount() != 0;
            }
        }
        return false;
    });
    return meterMap.keySet();
}
 

private void reportCounter(MetricId key, Counting value) {
    key = MetricId.join(prefix, key);

    final Metric m = FastForward
        .metric(key.getKey())
        .attributes(key.getTags())
        .attribute(METRIC_TYPE, "counter");

    send(m.value(value.getCount()));
}
 

private boolean canSkipMetric(String name, Counting counting) {
    boolean isIdle = (calculateDelta(name, counting.getCount()) == 0);
    if (skipIdleMetrics && !isIdle) {
        previousValues.put(name, counting.getCount());
    }
    return skipIdleMetrics && isIdle;
}
 

private static void assertSummary(Map<String, ?> map, String property, int expectedCount) {
    assertThat(((Counting) map.get(clientMetricNameWithStatus(property, 200))).getCount())
            .isEqualTo(expectedCount);
    assertThat(((Sampling) map.get(clientMetricNameWithStatus(property, 200))).getSnapshot().getMean())
            .isPositive();
    assertThat(((Counting) map.get(serverMetricNameWithStatus(property, 200))).getCount())
            .isEqualTo(expectedCount);
    assertThat(((Sampling) map.get(serverMetricNameWithStatus(property, 200))).getSnapshot().getMean())
            .isPositive();
}
 

private long diffLast(Counting metric) {
    long count = metric.getCount();

    Long lastCount = lastPolledCounts.get(metric);
    lastPolledCounts.put(metric, count);

    if (lastCount == null) {
        lastCount = 0L;
    }
    return count - lastCount;
}
 

private void reportCounter(
    final BatchBuilder builder, final Counting value
) {
    builder.buildPoint("count", value.getCount());
}
 

private void reportCounter(List<Point> points, String prefix, String name, Counting counter, long timestamp)
    throws IOException {
  String metricName = getKey(prefix, name, COUNT.getName());
  points.add(buildMetricAsPoint(metricName, counter.getCount(), false, timestamp));
}
 

private void reportCounter(String prefix, String name, Counting counter, long timestamp) throws IOException {
  String metricName = getKey(prefix, name, COUNT.getName());
  pushMetric(metricName, counter.getCount(), false, timestamp);
}
 

private void addCounting(String metricName, Counting value, long scale) {
  context.getCounter("morphline", metricName).increment(value.getCount() / scale);
}
 

private void addCounting(Context context, String metricName, Counting value, long scale) {
    final String COUNTER_GROUP = "HBase Indexer Metrics";
    context.getCounter(COUNTER_GROUP, metricName).increment(value.getCount() / scale);
}
 

/**
 * Extracts metrics from {@link com.codahale.metrics.Counter}.
 *
 * @param name name of the {@link com.codahale.metrics.Counter}.
 * @param counter instance of {@link com.codahale.metrics.Counter} to serialize.
 * @return a list of {@link org.apache.gobblin.metrics.Metric}.
 */
protected List<Metric> serializeCounter(String name, Counting counter) {
  return Lists.newArrayList(
      serializeValue(name, counter.getCount(), Measurements.COUNT.name())
  );
}