private void reportMeter(String name, Metered meter, long now) {
    if (canSkipMetric(name, meter)) {
        return;
    }
    Map<String, Object> fields = new HashMap<String, Object>();
    fields.put("count", meter.getCount());
    fields.put("m1_rate", convertRate(meter.getOneMinuteRate()));
    fields.put("m5_rate", convertRate(meter.getFiveMinuteRate()));
    fields.put("m15_rate", convertRate(meter.getFifteenMinuteRate()));
    fields.put("mean_rate", convertRate(meter.getMeanRate()));

    if (includeMeterFields != null) {
        fields.keySet().retainAll(includeMeterFields);
    }

    influxDb.appendPoints(
        new InfluxDbPoint(
            getMeasurementName(name),
            getTags(name),
            now,
            fields));
}
 

void addMetered(String baseName, Metered metered) {
    addMetric(metered, baseName,
            SignalFxReporter.MetricDetails.COUNT,
            SignalFxProtocolBuffers.MetricType.CUMULATIVE_COUNTER, metered.getCount());
    addMetric(metered, baseName,
            SignalFxReporter.MetricDetails.RATE_15_MIN,
            SignalFxProtocolBuffers.MetricType.GAUGE, metered.getFifteenMinuteRate());
    addMetric(metered, baseName,
            SignalFxReporter.MetricDetails.RATE_1_MIN,
            SignalFxProtocolBuffers.MetricType.GAUGE, metered.getOneMinuteRate());
    addMetric(metered, baseName,
            SignalFxReporter.MetricDetails.RATE_5_MIN,
            SignalFxProtocolBuffers.MetricType.GAUGE, metered.getFiveMinuteRate());

    addMetric(metered, baseName,
            SignalFxReporter.MetricDetails.RATE_MEAN,
            SignalFxProtocolBuffers.MetricType.GAUGE, metered.getMeanRate());
}
 

private void reportMetered(String name, Metered meter, long timestamp) {
    MeteredPrefixes meteredPrefixes = this.meteredPrefixes.getUnchecked(name);

    doSend(meteredPrefixes.count, meter.getCount(), timestamp);
    doSend(meteredPrefixes.m1_rate, convertRate(meter.getOneMinuteRate()), timestamp);
    doSend(meteredPrefixes.m5_rate, convertRate(meter.getFiveMinuteRate()), timestamp);
    doSend(meteredPrefixes.m15_rate, convertRate(meter.getFifteenMinuteRate()), timestamp);
    doSend(meteredPrefixes.mean_rate, convertRate(meter.getMeanRate()), timestamp);
}
 

private void writeMetered(String dropwizardName, Metered metered) throws IOException {
    String name = sanitizeMetricName(dropwizardName);
    writer.writeSample(name, mapOf("rate", "m1"), metered.getOneMinuteRate());
    writer.writeSample(name, mapOf("rate", "m5"), metered.getFiveMinuteRate());
    writer.writeSample(name, mapOf("rate", "m15"), metered.getFifteenMinuteRate());
    writer.writeSample(name, mapOf("rate", "mean"), metered.getMeanRate());
}
 

private void reportMetered(
    final BatchBuilder builder, final Metered value
) {
    final BatchBuilder b = builder.withUnit(builder.getUnit() + "/s");

    b.buildPoint("1m", value.getOneMinuteRate());
    b.buildPoint("5m", value.getFiveMinuteRate());
}
 

@BeforeClass
public static void setupCluster() throws Exception {
  // create one more node then shard, so that we also test the case of proxied requests.
  Builder clusterBuilder = configureCluster(3)
      .addConfig("conf", TEST_PATH().resolve("configsets").resolve("exitable-directory").resolve("conf"));
  clusterBuilder.withMetrics(true);
  clusterBuilder
      .configure();

  // pick an arbitrary node to use for our requests
  client = cluster.getRandomJetty(random()).newClient();

  CollectionAdminRequest.createCollection(COLLECTION, "conf", 2, 1)
      .processAndWait(cluster.getSolrClient(), DEFAULT_TIMEOUT);
  cluster.getSolrClient().waitForState(COLLECTION, DEFAULT_TIMEOUT, TimeUnit.SECONDS,
      (n, c) -> DocCollection.isFullyActive(n, c, 2, 1));

  fiveHundredsByNode = new LinkedHashMap<>();
  int httpOk = 0;
  for (JettySolrRunner jetty: cluster.getJettySolrRunners()) {
    MetricRegistry metricRegistry = ((JettySolrRunnerWithMetrics)jetty).getMetricRegistry();
    
    httpOk += ((Metered) metricRegistry.getMetrics()
               .get("org.eclipse.jetty.servlet.ServletContextHandler.2xx-responses")).getCount();
    
    Metered old = fiveHundredsByNode.put(jetty.getNodeName(),
        (Metered) metricRegistry.getMetrics()
           .get("org.eclipse.jetty.servlet.ServletContextHandler.5xx-responses"));
    assertNull("expecting uniq nodenames",old);
  }
  assertTrue("expecting some http activity during collection creation", httpOk > 0);
  indexDocs();
}
 

private void addMeterDataObject(String key, Metered meter, long clock, List<DataObject> dataObjectList) {
	dataObjectList.add(toDataObject(key, ".count", meter.getCount(), clock));
	dataObjectList.add(toDataObject(key, ".meanRate", convertRate(meter.getMeanRate()), clock));
	dataObjectList.add(toDataObject(key, ".1-minuteRate", convertRate(meter.getOneMinuteRate()), clock));
	dataObjectList.add(toDataObject(key, ".5-minuteRate", convertRate(meter.getFiveMinuteRate()), clock));
	dataObjectList.add(toDataObject(key, ".15-minuteRate", convertRate(meter.getFifteenMinuteRate()), clock));
}
 

private void writeMetered(JsonGenerator json, Metered meter) throws IOException {
  json.writeNumberField("count", convertRate(meter.getCount()));
  json.writeNumberField("mean", convertRate(meter.getMeanRate()));
  json.writeNumberField("m1", convertRate(meter.getOneMinuteRate()));
  json.writeNumberField("m5", convertRate(meter.getFiveMinuteRate()));
  json.writeNumberField("m15", convertRate(meter.getFifteenMinuteRate()));
}
 

private static void populateMetered(JsonObject json, Metered meter, TimeUnit rateUnit) {
  double factor = rateUnit.toSeconds(1);
  json.put("count", meter.getCount());
  json.put("meanRate", meter.getMeanRate() * factor);
  json.put("oneMinuteRate", meter.getOneMinuteRate() * factor);
  json.put("fiveMinuteRate", meter.getFiveMinuteRate() * factor);
  json.put("fifteenMinuteRate", meter.getFifteenMinuteRate() * factor);
  String rate = "events/" + rateUnit.toString().toLowerCase();
  json.put("rate", rate);
}
 

private void reportMetered(List<Point> points, String prefix, String name, Metered metered, long timestamp)
    throws IOException {
  reportCounter(points,prefix, name, metered, timestamp);
  String baseMetricName = getKey(prefix, name);
  points.add(buildRateAsPoint(getKey(baseMetricName, RATE_1MIN), metered.getOneMinuteRate(), timestamp));
  points.add(buildRateAsPoint(getKey(baseMetricName, RATE_5MIN), metered.getFiveMinuteRate(), timestamp));
  points.add(buildRateAsPoint(getKey(baseMetricName, RATE_15MIN), metered.getFifteenMinuteRate(), timestamp));
  points.add(buildRateAsPoint(getKey(baseMetricName, MEAN_RATE), metered.getMeanRate(), timestamp));
}
 

private void reportMetered(String prefix, String name, Metered metered, long timestamp) throws IOException {
  reportCounter(prefix, name, metered, timestamp);
  String baseMetricName = getKey(prefix, name);
  pushMetricRate(getKey(baseMetricName, RATE_1MIN), metered.getOneMinuteRate(), timestamp);
  pushMetricRate(getKey(baseMetricName, RATE_5MIN), metered.getFiveMinuteRate(), timestamp);
  pushMetricRate(getKey(baseMetricName, RATE_15MIN), metered.getFifteenMinuteRate(), timestamp);
  pushMetricRate(getKey(baseMetricName, MEAN_RATE), metered.getMeanRate(), timestamp);
}
 

/**
 * Extracts metrics from {@link com.codahale.metrics.Metered}.
 *
 * @param name name of the {@link com.codahale.metrics.Metered}.
 * @param meter instance of {@link com.codahale.metrics.Metered} to serialize.
 * @return a list of {@link org.apache.gobblin.metrics.Metric}.
 */
protected List<Metric> serializeMetered(String name, Metered meter) {
  return Lists.newArrayList(
    serializeValue(name, meter.getCount(), Measurements.COUNT.name()),
    serializeValue(name, meter.getMeanRate(), Measurements.MEAN_RATE.name()),
    serializeValue(name, meter.getOneMinuteRate(), Measurements.RATE_1MIN.name()),
    serializeValue(name, meter.getFiveMinuteRate(), Measurements.RATE_5MIN.name()),
    serializeValue(name, meter.getFifteenMinuteRate(), Measurements.RATE_15MIN.name())
  );
}
 

protected void writeMetered(Metered metered, BufferedWriter writer) throws IOException {
    writeWithIndent("count = " + metered.getCount(), writer);
    writeWithIndent("mean rate = " + getRateString(metered.getMeanRate()), writer);
    writeWithIndent("1-minute rate = " + getRateString(metered.getOneMinuteRate()), writer);
    writeWithIndent("5-minute rate = " + getRateString(metered.getFiveMinuteRate()), writer);
    writeWithIndent("15-minute rate = " + getRateString(metered.getFifteenMinuteRate()), writer);
    writeWithIndent("rate unit = " + rateUnit, writer);
}
 

public RatioGauge ratio1(Metered numerator, Metered denominator) {
   Preconditions.checkNotNull(numerator, "Numerator cannot be null.");
   Preconditions.checkNotNull(denominator, "Denominator cannot be null.");
   return new MeteredRatio1(numerator, denominator);
}
 

public RatioGauge ratio5(Metered numerator, Metered denominator) {
   Preconditions.checkNotNull(numerator, "Numerator cannot be null.");
   Preconditions.checkNotNull(denominator, "Denominator cannot be null.");
   return new MeteredRatio5(numerator, denominator);
}
 

public RatioGauge ratio15(Metered numerator, Metered denominator) {
   Preconditions.checkNotNull(numerator, "Numerator cannot be null.");
   Preconditions.checkNotNull(denominator, "Denominator cannot be null.");
   return new MeteredRatio15(numerator, denominator);
}
 

public RatioGauge ratio1(String name, Metered numerator, Metered denominator) {
   return register(name, ratio1(numerator, denominator));
}
 

public RatioGauge ratio5(String name, Metered numerator, Metered denominator) {
   return register(name, ratio5(numerator, denominator));
}
 

public RatioGauge ratio15(String name, Metered numerator, Metered denominator) {
   return register(name, ratio15(numerator, denominator));
}
 

public MeteredRatio1(Metered numerator, Metered denominator) {
   this.numerator = numerator;
   this.denominator = denominator;
}
 

public MeteredRatio5(Metered numerator, Metered denominator) {
   this.numerator = numerator;
   this.denominator = denominator;
}
 

public MeteredRatio15(Metered numerator, Metered denominator) {
   this.numerator = numerator;
   this.denominator = denominator;
}
 

private void reportMetered(final Metric m, Metered value) {
    final String u = getUnit(m);
    final Metric r = m.attribute("unit", u + "/s");
    send(r.attribute("stat", "1m").value(value.getOneMinuteRate()));
    send(r.attribute("stat", "5m").value(value.getFiveMinuteRate()));
}
 

private JmxMeter(Metered metric, ObjectName objectName, TimeUnit rateUnit, String tag) {
  super(objectName, tag);
  this.metric = metric;
  this.rateFactor = rateUnit.toSeconds(1);
  this.rateUnit = ("events/" + calculateRateUnit(rateUnit)).intern();
}
 

public static Builder<Metered> whenOneMinuteRateGreaterThan(final double value) {
    return LimitCheckers.<Metered>builder().limit(new OneMinuteRate(new GreaterThan<>(value)));
}
 

@Override
Double getMetric(Metered metric) {
    return metric.getOneMinuteRate();
}
 

private void addMetered(String name, Metered metered, LinkedList<PutMetricDataRequest> requests, Date timestamp) {
    checkAndAddDatum(MetricFilter.Stat.RATE_1_MINUTE, name, metered.getOneMinuteRate(), requests, timestamp);
    checkAndAddDatum(MetricFilter.Stat.RATE_5_MINUTE, name, metered.getFiveMinuteRate(), requests, timestamp);
    checkAndAddDatum(MetricFilter.Stat.RATE_15_MINUTE, name, metered.getFifteenMinuteRate(), requests, timestamp);
    checkAndAddDatum(MetricFilter.Stat.MEAN, name, metered.getMeanRate(), requests, timestamp);
}
 

private void reportMetered(Metric metric, Metered metered) {
  //purposefully don't emit 15m as it is not very useful
  send(metric.attribute("stat", "1m").value(metered.getOneMinuteRate()));
  send(metric.attribute("stat", "5m").value(metered.getOneMinuteRate()));
}
 

/**
 * The rates of {@link Metered} are reported after being converted using the rate factor, which is deduced from
 * the set rate unit
 *
 * @see Timer#getSnapshot
 * @see #getRateUnit
 * @see #convertRate(double)
 */
private void processMeter(final String metricName, final Metered meter, final List<MetricDatum> metricData) {
    final String formattedRate = String.format("-rate [per-%s]", getRateUnit());
    stageMetricDatum(builder.withOneMinuteMeanRate, metricName, convertRate(meter.getOneMinuteRate()), rateUnit, "1-min-mean" + formattedRate, metricData);
    stageMetricDatum(builder.withFiveMinuteMeanRate, metricName, convertRate(meter.getFiveMinuteRate()), rateUnit, "5-min-mean" + formattedRate, metricData);
    stageMetricDatum(builder.withFifteenMinuteMeanRate, metricName, convertRate(meter.getFifteenMinuteRate()), rateUnit, "15-min-mean" + formattedRate, metricData);
    stageMetricDatum(builder.withMeanRate, metricName, convertRate(meter.getMeanRate()), rateUnit, "mean" + formattedRate, metricData);
}