Java Code Examples for com.codahale.metrics.MetricRegistry#getMetrics()

/**
 * Register all metrics in the provided {@link MetricSet}, optionally skipping those that
 * already exist.
 *
 * @param registry   registry name
 * @param metrics    metric set to register
 * @param strategy   the conflict resolution strategy to use if the named metric already exists.
 * @param metricPath (optional) additional top-most metric name path elements
 * @throws Exception if a metric with this name already exists.
 */
public void registerAll(String registry, MetricSet metrics, ResolutionStrategy strategy, String... metricPath) throws Exception {
  MetricRegistry metricRegistry = registry(registry);
  synchronized (metricRegistry) {
    Map<String, Metric> existingMetrics = metricRegistry.getMetrics();
    for (Map.Entry<String, Metric> entry : metrics.getMetrics().entrySet()) {
      String fullName = mkName(entry.getKey(), metricPath);
      if (existingMetrics.containsKey(fullName)) {
        if (strategy == ResolutionStrategy.REPLACE) {
          metricRegistry.remove(fullName);
        } else if (strategy == ResolutionStrategy.IGNORE) {
          continue;
        } // strategy == ERROR will fail when we try to register later
      }
      metricRegistry.register(fullName, entry.getValue());
    }
  }
}
 

/**
 * Convert selected metrics to maps or to flattened objects.
 * @param registry source of metrics
 * @param shouldMatchFilters metrics must match any of these filters
 * @param mustMatchFilter metrics must match this filter
 * @param propertyFilter limit what properties of a metric are returned
 * @param skipHistograms discard any {@link Histogram}-s and histogram parts of {@link Timer}-s.
 * @param skipAggregateValues discard internal values of {@link AggregateMetric}-s.
 * @param compact use compact representation for counters and gauges.
 * @param simple use simplified representation for complex metrics - instead of a (name, map)
 *             only the selected (name "." key, value) pairs will be produced.
 * @param consumer consumer that accepts produced objects
 */
public static void toMaps(MetricRegistry registry, List<MetricFilter> shouldMatchFilters,
                   MetricFilter mustMatchFilter, PropertyFilter propertyFilter,
                   boolean skipHistograms, boolean skipAggregateValues,
                   boolean compact, boolean simple,
                   BiConsumer<String, Object> consumer) {
  final Map<String, Metric> metrics = registry.getMetrics();
  final SortedSet<String> names = registry.getNames();
  names.stream()
      .filter(s -> shouldMatchFilters.stream().anyMatch(metricFilter -> metricFilter.matches(s, metrics.get(s))))
      .filter(s -> mustMatchFilter.matches(s, metrics.get(s)))
      .forEach(n -> {
        Metric metric = metrics.get(n);
        convertMetric(n, metric, propertyFilter, skipHistograms, skipAggregateValues, compact, simple, ".", consumer);
      });
}
 

/**
 * Make sure that in a single life cycle the correct metrics are registered, the correct {@link ProcessGroupStatus}
 * is used and that metrics are actually reported.
 */
@Test
public void testValidLifeCycleReportsCorrectly() throws Exception {
    reportingContextStub.getEventAccess().setProcessGroupStatus(rootGroupStatus);

    testedReportingTask.initialize(reportingInitContextStub);
    testedReportingTask.connect(configurationContextStub);
    testedReportingTask.onTrigger(reportingContextStub);
    verify(reporterMock).report();

    // Verify correct metrics are registered
    ArgumentCaptor<MetricRegistry> registryCaptor = ArgumentCaptor.forClass(MetricRegistry.class);
    verify(reporterServiceStub).createReporter(registryCaptor.capture());
    MetricRegistry usedRegistry = registryCaptor.getValue();
    Map<String, Metric> usedMetrics = usedRegistry.getMetrics();
    assertTrue(usedMetrics.keySet().containsAll(new MemoryUsageGaugeSet().getMetrics().keySet()));
    assertTrue(usedMetrics.keySet()
            .containsAll(new FlowMetricSet(testedReportingTask.currentStatusReference).getMetrics().keySet()));

    // Verify the most current ProcessGroupStatus is updated
    assertEquals(testedReportingTask.currentStatusReference.get(), rootGroupStatus);
}
 

/**
 * Make sure that in a single life cycle the correct metrics are registered, the correct {@link ProcessGroupStatus}
 * is used and that metrics are actually reported.
 */
@Test
public void testValidLifeCycleReportsCorrectlyProcessGroupSpecified() throws Exception {
    reportingContextStub.setProperty(MetricsReportingTask.PROCESS_GROUP_ID.getName(), TEST_GROUP_ID);
    reportingContextStub.getEventAccess().setProcessGroupStatus(TEST_GROUP_ID, innerGroupStatus);

    testedReportingTask.initialize(reportingInitContextStub);
    testedReportingTask.connect(configurationContextStub);
    testedReportingTask.onTrigger(reportingContextStub);
    verify(reporterMock).report();

    // Verify correct metrics are registered
    ArgumentCaptor<MetricRegistry> registryCaptor = ArgumentCaptor.forClass(MetricRegistry.class);
    verify(reporterServiceStub).createReporter(registryCaptor.capture());
    MetricRegistry usedRegistry = registryCaptor.getValue();
    Map<String, Metric> usedMetrics = usedRegistry.getMetrics();
    assertTrue(usedMetrics.keySet().containsAll(new MemoryUsageGaugeSet().getMetrics().keySet()));
    assertTrue(usedMetrics.keySet()
            .containsAll(new FlowMetricSet(testedReportingTask.currentStatusReference).getMetrics().keySet()));

    // Verify the most current ProcessGroupStatus is updated
    assertEquals(testedReportingTask.currentStatusReference.get(), innerGroupStatus);
}
 

@Test
public void testCoreContainerMetrics() throws Exception {
  String registryName = SolrMetricManager.getRegistryName(SolrInfoBean.Group.node);
  assertTrue(cc.getMetricManager().registryNames().toString(), cc.getMetricManager().registryNames().contains(registryName));
  MetricRegistry registry = cc.getMetricManager().registry(registryName);
  Map<String, Metric> metrics = registry.getMetrics();
  assertTrue(metrics.containsKey("CONTAINER.cores.loaded"));
  assertTrue(metrics.containsKey("CONTAINER.cores.lazy"));
  assertTrue(metrics.containsKey("CONTAINER.cores.unloaded"));
  assertTrue(metrics.containsKey("CONTAINER.fs.totalSpace"));
  assertTrue(metrics.containsKey("CONTAINER.fs.usableSpace"));
  assertTrue(metrics.containsKey("CONTAINER.fs.path"));
  assertTrue(metrics.containsKey("CONTAINER.fs.spins"));
  assertTrue(metrics.containsKey("CONTAINER.fs.coreRoot.totalSpace"));
  assertTrue(metrics.containsKey("CONTAINER.fs.coreRoot.usableSpace"));
  assertTrue(metrics.containsKey("CONTAINER.fs.coreRoot.path"));
  assertTrue(metrics.containsKey("CONTAINER.fs.coreRoot.spins"));
  assertTrue(metrics.containsKey("CONTAINER.version.specification"));
  assertTrue(metrics.containsKey("CONTAINER.version.implementation"));
  Gauge<?> g = (Gauge<?>)metrics.get("CONTAINER.fs.path");
  assertEquals(g.getValue(), cc.getSolrHome());
  boolean spins = IOUtils.spins(cc.getCoreRootDirectory());
  g = (Gauge<?>)metrics.get("CONTAINER.fs.coreRoot.spins");
  assertEquals(spins, g.getValue());
  g = (Gauge<?>)metrics.get("CONTAINER.fs.spins");
  if (cc.getConfig().getSolrDataHome() != null) {
    spins = IOUtils.spins(cc.getConfig().getSolrDataHome());
    assertEquals(spins, g.getValue());
  } else {
    assertEquals(spins, g.getValue());
  }
}
 

@Test
public void testIndexNoMetrics() throws Exception {
  System.setProperty("solr.tests.metrics.merge", "false");
  System.setProperty("solr.tests.metrics.mergeDetails", "false");
  initCore("solrconfig-indexmetrics.xml", "schema.xml");

  addDocs();

  MetricRegistry registry = h.getCoreContainer().getMetricManager().registry(h.getCore().getCoreMetricManager().getRegistryName());
  assertNotNull(registry);

  Map<String, Metric> metrics = registry.getMetrics();
  // INDEX.size, INDEX.sizeInBytes
  assertEquals(2, metrics.entrySet().stream().filter(e -> e.getKey().startsWith("INDEX")).count());
}
 

private Map<String, Metric> getMetrics() {
  SolrMetricManager manager = h.getCoreContainer().getMetricManager();
  MetricRegistry registry = manager.registry(h.getCore().getCoreMetricManager().getRegistryName());
  return registry.getMetrics();
}
 

@Test
//commented 2-Aug-2018 @BadApple(bugUrl="https://issues.apache.org/jira/browse/SOLR-12028")
public void test() throws Exception {
  handle.clear();
  handle.put("timestamp", SKIPVAL);

  waitForThingsToLevelOut(30, TimeUnit.SECONDS);

  del("*:*");

  // index enough docs and commit to establish frame of reference for PeerSync
  for (int i = 0; i < 100; i++) {
    indexDoc(id, docId, i1, 50, tlong, 50, t1,
        "document number " + docId++);
  }
  commit();
  waitForThingsToLevelOut(30, TimeUnit.SECONDS);

  try {
    checkShardConsistency(false, true);

    long cloudClientDocs = cloudClient.query(new SolrQuery("*:*")).getResults().getNumFound();
    assertEquals(docId, cloudClientDocs);

    CloudJettyRunner initialLeaderJetty = shardToLeaderJetty.get("shard1");
    List<CloudJettyRunner> otherJetties = getOtherAvailableJetties(initialLeaderJetty);
    CloudJettyRunner neverLeader = otherJetties.get(otherJetties.size() - 1);
    otherJetties.remove(neverLeader) ;

    // first shutdown a node that will never be a leader
    forceNodeFailures(singletonList(neverLeader));

    // node failure and recovery via PeerSync
    log.info("Forcing PeerSync");
    CloudJettyRunner nodePeerSynced = forceNodeFailureAndDoPeerSync(false);

    // add a few more docs
    indexDoc(id, docId, i1, 50, tlong, 50, t1,
        "document number " + docId++);
    indexDoc(id, docId, i1, 50, tlong, 50, t1,
        "document number " + docId++);
    commit();

    cloudClientDocs = cloudClient.query(new SolrQuery("*:*")).getResults().getNumFound();
    assertEquals(docId, cloudClientDocs);

    // now shutdown all other nodes except for 'nodeShutDownForFailure'
    otherJetties.remove(nodePeerSynced);
    forceNodeFailures(otherJetties);
    waitForThingsToLevelOut(30, TimeUnit.SECONDS);
    checkShardConsistency(false, true);

    // now shutdown the original leader
    log.info("Now shutting down initial leader");
    forceNodeFailures(singletonList(initialLeaderJetty));
    log.info("Updating mappings from zk");
    waitForNewLeader(cloudClient, "shard1", (Replica) initialLeaderJetty.client.info, new TimeOut(15, TimeUnit.SECONDS, TimeSource.NANO_TIME));
    updateMappingsFromZk(jettys, clients, true);
    assertEquals("PeerSynced node did not become leader", nodePeerSynced, shardToLeaderJetty.get("shard1"));

    // bring up node that was down all along, and let it PeerSync from the node that was forced to PeerSynce  
    bringUpDeadNodeAndEnsureNoReplication(neverLeader, false);
    waitTillNodesActive();

    checkShardConsistency(false, true);

    
    // bring back all the nodes including initial leader 
    // (commented as reports Maximum concurrent create/delete watches above limit violation and reports thread leaks)
    /*for(int i = 0 ; i < nodesDown.size(); i++) {
      bringUpDeadNodeAndEnsureNoReplication(shardToLeaderJetty.get("shard1"), neverLeader, false);
    }
    checkShardConsistency(false, true);*/

    // make sure leader has not changed after bringing initial leader back
    assertEquals(nodePeerSynced, shardToLeaderJetty.get("shard1"));

    // assert metrics
    SolrMetricManager manager = nodePeerSynced.jetty.getCoreContainer().getMetricManager();
    MetricRegistry registry = null;
    for (String name : manager.registryNames()) {
      if (name.startsWith("solr.core.collection1")) {
        registry = manager.registry(name);
        break;
      }
    }
    assertNotNull(registry);
    Map<String, Metric> metrics = registry.getMetrics();
    assertTrue("REPLICATION.peerSync.time present", metrics.containsKey("REPLICATION.peerSync.time"));
    assertTrue("REPLICATION.peerSync.errors present", metrics.containsKey("REPLICATION.peerSync.errors"));

    Counter counter = (Counter)metrics.get("REPLICATION.peerSync.errors");
    assertEquals(0L, counter.getCount());
    success = true;
  } finally {
    System.clearProperty("solr.disableFingerprint");
  }
}
 

/**
 * Convert selected metrics from a registry into maps (when <code>compact==false</code>) or
 * flattened objects.
 * @param registry registry
 * @param names metric names
 * @param skipHistograms discard any {@link Histogram}-s and histogram parts of {@link Timer}-s.
 * @param skipAggregateValues discard internal values of {@link AggregateMetric}-s.
 * @param compact use compact representation for counters and gauges.
 * @param simple use simplified representation for complex metrics - instead of a (name, map)
 *             only the selected (name "." key, value) pairs will be produced.
 * @param consumer consumer that accepts produced objects
 */
public static void convertMetrics(MetricRegistry registry, Collection<String> names,
                                  boolean skipHistograms, boolean skipAggregateValues,
                                  boolean compact, boolean simple,
                                  BiConsumer<String, Object> consumer) {
  final Map<String, Metric> metrics = registry.getMetrics();
  names.stream()
      .forEach(n -> {
        Metric metric = metrics.get(n);
        convertMetric(n, metric, PropertyFilter.ALL, skipHistograms, skipAggregateValues, compact, simple, ".", consumer);
      });
}