Пример #1
0
 private Delta<?> calculateDelta(Metric<?> value) {
   long delta = value.getValue().longValue();
   Long old = this.counts.replace(value.getName(), delta);
   if (old != null) {
     delta = delta - old;
   } else {
     this.counts.putIfAbsent(value.getName(), delta);
   }
   return new Delta<Long>(value.getName(), delta, value.getTimestamp());
 }
 @Override
 public void set(String group, Collection<Metric<?>> values) {
   String prefix = group;
   if (!prefix.endsWith(".")) {
     prefix = prefix + ".";
   }
   for (Metric<?> metric : values) {
     if (!metric.getName().startsWith(prefix)) {
       metric =
           new Metric<Number>(prefix + metric.getName(), metric.getValue(), metric.getTimestamp());
     }
     set(metric);
   }
   this.groups.add(group);
 }
  @Test
  public void testMetrics() throws Exception {
    InMemoryRichGaugeRepository repository = new InMemoryRichGaugeRepository();

    repository.set(new Metric<Double>("a", 0.d, new Date()));
    repository.set(new Metric<Double>("a", 0.5d, new Date()));

    RichGaugeReaderPublicMetrics metrics = new RichGaugeReaderPublicMetrics(repository);

    Map<String, Metric<?>> results = new HashMap<String, Metric<?>>();
    for (Metric<?> metric : metrics.metrics()) {
      results.put(metric.getName(), metric);
    }
    assertThat(results.containsKey("a.val")).isTrue();
    assertThat(results.get("a.val").getValue().doubleValue()).isEqualTo(0.5d);

    assertThat(results.containsKey("a.avg")).isTrue();
    assertThat(results.get("a.avg").getValue().doubleValue()).isEqualTo(0.25d);

    assertThat(results.containsKey("a.min")).isTrue();
    assertThat(results.get("a.min").getValue().doubleValue()).isEqualTo(0.0d);

    assertThat(results.containsKey("a.max")).isTrue();
    assertThat(results.get("a.max").getValue().doubleValue()).isEqualTo(0.5d);

    assertThat(results.containsKey("a.count")).isTrue();
    assertThat(results.get("a.count").getValue().longValue()).isEqualTo(2L);

    assertThat(results.containsKey("a.alpha")).isTrue();
    assertThat(results.get("a.alpha").getValue().doubleValue()).isEqualTo(-1.d);
  }
Пример #4
0
 private boolean isMatch(Metric<?> metric) {
   String[] includes = MetricCopyExporter.this.includes;
   String[] excludes = MetricCopyExporter.this.excludes;
   String name = metric.getName();
   if (ObjectUtils.isEmpty(includes) || PatternMatchUtils.simpleMatch(includes, name)) {
     return !PatternMatchUtils.simpleMatch(excludes, name);
   }
   return false;
 }
 @Test
 public void prefixWithPeriod() {
   this.repository.increment(new Delta<Number>("foo.bar", 1));
   Set<String> names = new HashSet<String>();
   for (Metric<?> metric : this.repository.findAll("foo.")) {
     names.add(metric.getName());
   }
   assertThat(names).hasSize(1);
   assertThat(names.contains("foo.bar")).isTrue();
 }
Пример #6
0
 @Override
 protected void write(String group, Collection<Metric<?>> values) {
   for (Metric<?> value : values) {
     if (value.getName().startsWith("counter.") && this.counter != null) {
       this.counter.increment(calculateDelta(value));
     } else {
       this.writer.set(value);
     }
   }
 }
 @Test
 public void onlyRegisteredPrefixCounted() {
   this.repository.increment(new Delta<Number>("foo.bar", 1));
   this.repository.increment(new Delta<Number>("foobar.spam", 1));
   Set<String> names = new HashSet<String>();
   for (Metric<?> metric : this.repository.findAll("foo")) {
     names.add(metric.getName());
   }
   assertThat(names).hasSize(1);
   assertThat(names.contains("foo.bar")).isTrue();
 }
 @Test
 public void testMetrics() throws Exception {
   InMemoryMetricRepository repository = new InMemoryMetricRepository();
   repository.set(new Metric<Double>("a", 0.5, new Date()));
   VanillaPublicMetrics publicMetrics = new VanillaPublicMetrics(repository);
   Map<String, Metric<?>> results = new HashMap<String, Metric<?>>();
   for (Metric<?> metric : publicMetrics.metrics()) {
     results.put(metric.getName(), metric);
   }
   assertThat(results.get("a").getValue().doubleValue(), equalTo(0.5));
 }
 @Test
 public void incrementGroup() {
   this.repository.increment("foo", new Delta<Number>("foo.bar", 1));
   this.repository.increment("foo", new Delta<Number>("foo.bar", 2));
   this.repository.increment("foo", new Delta<Number>("foo.spam", 1));
   Set<String> names = new HashSet<String>();
   for (Metric<?> metric : this.repository.findAll("foo")) {
     names.add(metric.getName());
   }
   assertThat(names).hasSize(2);
   assertThat(names.contains("foo.bar")).isTrue();
   assertThat(this.repository.findOne("foo.bar").getValue()).isEqualTo(3L);
 }
  @Test
  public void testAdditionalMetrics() throws Exception {
    InMemoryMetricRepository repository = new InMemoryMetricRepository();
    Collection<PublicMetrics> allMetrics = new ArrayList<PublicMetrics>();
    allMetrics.add(new ImmutablePublicMetrics(new Metric<Number>("first", 2L)));
    allMetrics.add(new ImmutablePublicMetrics(new Metric<Number>("second", 4L)));

    VanillaPublicMetrics publicMetrics = new VanillaPublicMetrics(repository, allMetrics);
    Map<String, Metric<?>> results = new HashMap<String, Metric<?>>();
    for (Metric<?> metric : publicMetrics.metrics()) {
      results.put(metric.getName(), metric);
    }
    assertTrue(results.containsKey("first"));
    assertTrue(results.containsKey("second"));
    assertEquals(2, results.size());
  }
Пример #11
0
 @Override
 public void set(Metric<?> value) {
   this.metrics.set(value.getName(), value);
 }