Java DefaultRegistry类代码示例

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void testAddMeasurementsToTimeSeries() {
  DefaultRegistry testRegistry = new DefaultRegistry(clock);

  long millisA = TimeUnit.MILLISECONDS.convert(1472394975L, TimeUnit.SECONDS);
  long millisB = millisA + 987;
  String timeA = "2016-08-28T14:36:15.000000000Z";
  String timeB = "2016-08-28T14:36:15.987000000Z";
  Meter timerA = testRegistry.timer(idAXY);
  Meter timerB = testRegistry.timer(idBXY);
  Measurement measureAXY = new Measurement(idAXY, millisA, 1);
  Measurement measureBXY = new Measurement(idBXY, millisB, 20.1);

  descriptorRegistrySpy.addExtraTimeSeriesLabel(
      MetricDescriptorCache.INSTANCE_LABEL, INSTANCE_ID);
  
  Assert.assertEquals(
      makeTimeSeries(descriptorA, idAXY, 1, timeA),
      writer.measurementToTimeSeries(descriptorA.getType(), testRegistry, timerA, measureAXY));
  Assert.assertEquals(
      makeTimeSeries(descriptorB, idBXY, 20.1, timeB),
      writer.measurementToTimeSeries(descriptorB.getType(), testRegistry, timerB, measureBXY));
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void basic() {
  Registry r = new DefaultRegistry();
  BucketDistributionSummary c = BucketDistributionSummary.get(
      r, r.createId("test"), BucketFunctions.latency(4, TimeUnit.SECONDS));

  c.record(TimeUnit.MILLISECONDS.toNanos(3750));
  Assert.assertEquals(1, r.distributionSummaries().count());
  Assert.assertEquals(1, sum(r, "test"));

  c.record(TimeUnit.MILLISECONDS.toNanos(4221));
  Assert.assertEquals(2, r.distributionSummaries().count());
  Assert.assertEquals(2, sum(r, "test"));

  c.record(TimeUnit.MILLISECONDS.toNanos(4221));
  Assert.assertEquals(2, r.distributionSummaries().count());
  Assert.assertEquals(3, sum(r, "test"));
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void basic() {
  Registry r = new DefaultRegistry();
  BucketTimer t = BucketTimer.get(
      r, r.createId("test"), BucketFunctions.latency(4, TimeUnit.SECONDS));

  t.record(3750, TimeUnit.MILLISECONDS);
  Assert.assertEquals(1, r.timers().count());
  Assert.assertEquals(1, sum(r, "test"));

  t.record(4221, TimeUnit.MILLISECONDS);
  Assert.assertEquals(2, r.timers().count());
  Assert.assertEquals(2, sum(r, "test"));

  t.record(4221, TimeUnit.MILLISECONDS);
  Assert.assertEquals(2, r.timers().count());
  Assert.assertEquals(3, sum(r, "test"));
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void basic() {
  Registry r = new DefaultRegistry();
  BucketCounter c = BucketCounter.get(
      r, r.createId("test"), BucketFunctions.latency(4, TimeUnit.SECONDS));

  c.record(TimeUnit.MILLISECONDS.toNanos(3750));
  Assert.assertEquals(1, r.counters().count());
  Assert.assertEquals(1, sum(r, "test"));

  c.record(TimeUnit.MILLISECONDS.toNanos(4221));
  Assert.assertEquals(2, r.counters().count());
  Assert.assertEquals(2, sum(r, "test"));

  c.record(TimeUnit.MILLISECONDS.toNanos(4221));
  Assert.assertEquals(2, r.counters().count());
  Assert.assertEquals(3, sum(r, "test"));
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void updateNextFixedDelay() {
  ManualClock clock = new ManualClock();
  Registry registry = new DefaultRegistry(clock);
  Counter skipped = registry.counter("skipped");

  Scheduler.Options options = new Scheduler.Options()
      .withFrequency(Scheduler.Policy.FIXED_DELAY, Duration.ofSeconds(10));

  clock.setWallTime(5437L);
  Scheduler.DelayedTask task = new Scheduler.DelayedTask(clock, options, () -> {});
  Assert.assertEquals(5437L, task.getNextExecutionTime());
  Assert.assertEquals(0L, skipped.count());

  clock.setWallTime(12123L);
  task.updateNextExecutionTime(skipped);
  Assert.assertEquals(22123L, task.getNextExecutionTime());
  Assert.assertEquals(0L, skipped.count());

  clock.setWallTime(27000L);
  task.updateNextExecutionTime(skipped);
  Assert.assertEquals(37000L, task.getNextExecutionTime());
  Assert.assertEquals(0L, skipped.count());
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void shutdownStopsThreads() throws Exception {
  Scheduler s = new Scheduler(new DefaultRegistry(), "shutdown", 1);

  // Schedule something to force it to start the threads
  Scheduler.Options opts = new Scheduler.Options()
      .withFrequency(Scheduler.Policy.FIXED_RATE_SKIP_IF_LONG, Duration.ofMillis(10))
      .withStopOnFailure(false);
  ScheduledFuture<?> f = s.schedule(opts, () -> {});
  Assert.assertEquals(1L, numberOfThreads("shutdown"));

  // Shutdown and wait a bit, this gives the thread a chance to restart
  s.shutdown();
  Thread.sleep(300);
  Assert.assertEquals(0L, numberOfThreads("shutdown"));
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void stopOnFailureFalseThrowable() throws Exception {
  Scheduler s = new Scheduler(new DefaultRegistry(), "test", 1);

  Scheduler.Options opts = new Scheduler.Options()
      .withFrequency(Scheduler.Policy.FIXED_RATE_SKIP_IF_LONG, Duration.ofMillis(10))
      .withStopOnFailure(false);

  final CountDownLatch latch = new CountDownLatch(5);
  ScheduledFuture<?> f = s.schedule(opts, () -> {
    latch.countDown();
    throw new IOError(new RuntimeException("stop"));
  });

  Assert.assertTrue(latch.await(60, TimeUnit.SECONDS));
  Assert.assertFalse(f.isDone());
  s.shutdown();
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void stopOnFailureFalse() throws Exception {
  Scheduler s = new Scheduler(new DefaultRegistry(), "test", 2);

  Scheduler.Options opts = new Scheduler.Options()
      .withFrequency(Scheduler.Policy.FIXED_DELAY, Duration.ofMillis(10))
      .withStopOnFailure(false);

  final CountDownLatch latch = new CountDownLatch(5);
  ScheduledFuture<?> f = s.schedule(opts, () -> {
    latch.countDown();
    throw new RuntimeException("stop");
  });

  Assert.assertTrue(latch.await(60, TimeUnit.SECONDS));
  Assert.assertFalse(f.isDone());
  s.shutdown();
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void stopOnFailureTrue() throws Exception {
  Scheduler s = new Scheduler(new DefaultRegistry(), "test", 2);

  Scheduler.Options opts = new Scheduler.Options()
      .withFrequency(Scheduler.Policy.FIXED_DELAY, Duration.ofMillis(10))
      .withStopOnFailure(true);

  final CountDownLatch latch = new CountDownLatch(1);
  ScheduledFuture<?> f = s.schedule(opts, () -> {
    latch.countDown();
    throw new RuntimeException("stop");
  });

  Assert.assertTrue(latch.await(60, TimeUnit.SECONDS));
  while (!f.isDone()); // This will be an endless loop if broken
  s.shutdown();
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void cancel() throws Exception {
  Scheduler s = new Scheduler(new DefaultRegistry(), "test", 2);

  Scheduler.Options opts = new Scheduler.Options()
      .withFrequency(Scheduler.Policy.FIXED_DELAY, Duration.ofMillis(10))
      .withStopOnFailure(false);

  final CountDownLatch latch = new CountDownLatch(1);
  final AtomicReference<ScheduledFuture<?>> ref = new AtomicReference<>();
  ref.set(s.schedule(opts, () -> {
    try {
      while (ref.get() == null);
      ref.get().cancel(true);
      Thread.sleep(600000L);
    } catch (InterruptedException e) {
      latch.countDown();
    }
  }));

  Assert.assertTrue(latch.await(60, TimeUnit.SECONDS));
  Assert.assertTrue(ref.get().isDone());
  s.shutdown();
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void threadsAreReplaced() throws Exception {
  Scheduler s = new Scheduler(new DefaultRegistry(), "test", 1);

  Scheduler.Options opts = new Scheduler.Options()
      .withFrequency(Scheduler.Policy.FIXED_DELAY, Duration.ofMillis(10))
      .withStopOnFailure(false);

  final CountDownLatch latch = new CountDownLatch(10);
  s.schedule(opts, () -> {
    latch.countDown();
    Thread.currentThread().interrupt();
  });

  Assert.assertTrue(latch.await(60, TimeUnit.SECONDS));
  s.shutdown();
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void testEncodeCombinedRegistry() {
  // Multiple occurrences of measurements in the same registry
  // (confirm these are handled within the registry itself).
  Measurement measureBXY2 = new Measurement(idBXY, 5, 5.5);
  Meter meterB2 = new TestMeter("ignoreB", measureBXY2);

  DefaultRegistry registry = new DefaultRegistry(clock);
  registry.register(meterB);
  registry.register(meterB2);

  List<TaggedDataPoints> expectedTaggedDataPoints = Arrays.asList(
     new TaggedDataPoints(
           Arrays.asList(new BasicTag("tagA", "X"),
                         new BasicTag("tagB", "Y")),
           Arrays.asList(new DataPoint(clock.wallTime(), 50.5 + 5.5))));

  HashMap<String, MetricValues> expect = new HashMap<>();
  expect.put("idB", new MetricValues("Counter", expectedTaggedDataPoints));

  Assert.assertEquals(expect, controller.encodeRegistry(registry, allowAll));
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void readLatency() throws Exception {
  Registry r = new DefaultRegistry(new ManualClock());
  List<JmxConfig> configs = configs();

  JmxData data = timer("keyspace=test,name=ReadLatency,scope=foo,type=ColumnFamily", 0);
  List<Measurement> ms = measure(r, configs, data);
  Assert.assertEquals(7, ms.size());
  Assert.assertEquals(
      50.0e-4,
      Utils.first(ms, "statistic", "percentile_50").value(),
      1e-12);

  data = timer("keyspace=test,name=ReadLatency,scope=foo,type=ColumnFamily", 1);
  ms = measure(r, configs, data);
  Assert.assertEquals(7, ms.size());
  Assert.assertEquals(
      50.01e-4,
      Utils.first(ms, "statistic", "percentile_50").value(),
      1e-12);
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
public static Collection<String> run() throws Exception {
  ManualClock clock = new ManualClock();
  clock.setWallTime(1234567890L);
  Registry r = new DefaultRegistry(clock);
  checkDistributionSummary(r);
  checkTimer(r);
  checkLongTaskTimer(r);
  checkCounter(r);
  checkGauge(r);

  // Histogram utilities
  checkBucketCounter(r, "age");
  checkBucketCounter(r, "ageBiasOld");
  checkBucketCounter(r, "latency");
  checkBucketCounter(r, "latencyBiasSlow");
  checkBucketCounter(r, "bytes");
  checkBucketCounter(r, "decimal");
  checkBucketDistributionSummary(r);
  checkBucketTimer(r);
  checkPercentileDistributionSummary(r);
  checkPercentileTimer(r);

  List<String> ms = new ArrayList<>();
  for (Meter meter : r) {
    for (Measurement m : meter.measure()) {
      ms.add(m.toString());
    }
  }
  Collections.sort(ms);
  return ms.stream()
      .filter(s -> !s.contains("non-deterministic"))
      .collect(Collectors.toList());
}
 

import com.netflix.spectator.api.DefaultRegistry; //导入依赖的package包/类
@Test
public void testMeasurementsToTimeSeries() throws IOException {
    Measurement measureAXY
        = new Measurement(idAXY, clock.monotonicTime(), 1);
    Measurement measureBXY
        = new Measurement(idBXY, clock.monotonicTime(), 2);

  DefaultRegistry testRegistry = new DefaultRegistry(clock);
  testRegistry.counter(idAXY).increment();
  testRegistry.counter(idBXY).increment(2);

  // Note this writer is still using the mock Monitoring client stub.
  TestableStackdriverWriter spy
      = spy(new TestableStackdriverWriter(writerConfig.build()));

  Meter counterA = testRegistry.counter(idAXY);
  Meter counterB = testRegistry.counter(idBXY);

  doReturn(new TimeSeries()).when(spy).measurementToTimeSeries(
      eq(descriptorA.getType()), eq(testRegistry), eq(counterA), eq(measureAXY));
  doReturn(new TimeSeries()).when(spy).measurementToTimeSeries(
      eq(descriptorB.getType()), eq(testRegistry), eq(counterB), eq(measureBXY));

  // Just testing the call flow produces descriptors since
  // we return empty TimeSeries values.
  spy.registryToTimeSeries(testRegistry);
}