private static Timer getTimer(String name, String...additionalTags) { String key = className + "." + name + "." + Joiner.on(",").join(additionalTags); return monitors.computeIfAbsent(key, k -> { List<Tag> tagList = getTags(additionalTags); tagList.add(new BasicTag("unit", TimeUnit.MILLISECONDS.name())); return registry.timer(name, tagList); }); }
/** Create an immutable instance of a tag. */ static Tag of(String key, String value) { return new BasicTag(key, value); } }
@Override public Tag next() { if (i >= length) { throw new NoSuchElementException("next called after end of iterator"); } final String k = tags[i++]; final String v = tags[i++]; return new BasicTag(k, v); } };
/** Add additional tag values. */ public T withTags(String... tags) { for (int i = 0; i < tags.length; i += 2) { extraTags.add(new BasicTag(tags[i], tags[i + 1])); } return (T) this; }
/** * Return a new id with additional tag values. This overload is to avoid allocating a * parameters array for the more generic varargs method {@link #withTags(String...)}. */ @SuppressWarnings("PMD.UseObjectForClearerAPI") default Id withTags(String k1, String v1, String k2, String v2) { final Tag[] ts = new Tag[] { new BasicTag(k1, v1), new BasicTag(k2, v2) }; return withTags(ts); }
private Counter counterFor(int i) { Counter c = counters.get(i); if (c == null) { Id counterId = id.withTags(Statistic.percentile, new BasicTag("percentile", TAG_VALUES[i])); c = registry.counter(counterId); counters.set(i, c); } return c; }
@Test public void testWithTagFactories() { Tag tags1 = new BasicTag("k1", "v1"); Tag tags2 = new BasicTag("k2", "v2"); List<TagFactory> factories = Arrays.asList(new ConstantTagFactory(tags1), new ConstantTagFactory(tags2)); DefaultPlaceholderId id = new DefaultPlaceholderId("foo", REGISTRY).withTagFactories(factories); Iterator<Tag> tags = id.resolveToId().tags().iterator(); Assertions.assertTrue(tags.hasNext(), "tags empty"); Assertions.assertEquals(tags1, tags.next()); Assertions.assertEquals(tags2, tags.next()); }
@Test public void testIteratorNext() { Assertions.assertThrows(NoSuchElementException.class, () -> { ArrayTagSet tag = ArrayTagSet.create("k", "v"); Iterator<Tag> iter = tag.iterator(); Assertions.assertTrue(iter.hasNext()); Assertions.assertEquals(new BasicTag("k", "v"), iter.next()); Assertions.assertFalse(iter.hasNext()); iter.next(); }); }
@Test public void addAllIterable() { // Add an arbitrary iterable that isn't a collection or ArrayTagSet Collection<Tag> tags = Collections.singletonList(new BasicTag("app", "foo")); ArrayTagSet ts = ArrayTagSet.EMPTY.addAll(tags::iterator); Assertions.assertEquals(ArrayTagSet.EMPTY.addAll(tags), ts); }
@SuppressWarnings("unchecked") @Test public void addTags() { Map<String, String> actual = (Map<String, String>) entry .addTag(new BasicTag("k1", "v1")) .addTag("k2", "v2") .convert(this::toMap) .get("additionalTags"); Assertions.assertEquals(2, actual.size()); Assertions.assertEquals("v1", actual.get("k1")); Assertions.assertEquals("v2", actual.get("k2")); }
@Test public void testWithTag() { Tag expected = new BasicTag("key", "value"); DefaultPlaceholderId id = new DefaultPlaceholderId("foo", REGISTRY).withTag(expected); Iterator<Tag> tags = id.resolveToId().tags().iterator(); Assertions.assertTrue(tags.hasNext(), "tags empty"); Assertions.assertEquals(expected, tags.next()); }
@Test public void addAllDedupEmpty() { ArrayTagSet ts = ArrayTagSet.EMPTY.addAll(new String[] {"a", "1", "a", "2", "a", "3"}); Assertions.assertEquals(ArrayTagSet.EMPTY.add(new BasicTag("a", "3")), ts); }
@Test public void testCreateTagUsingTagConstructor() throws Exception { Tag expected = new BasicTag("key", "value"); TagFactory factory = new ConstantTagFactory(expected); Tag actual = factory.createTag(); Assertions.assertSame(expected, actual); }
@Test public void filterPredicate() { List<Measurement> ms = newList(10); Tag t = new BasicTag("i", "7"); List<Measurement> out = Utils.toList(Utils.filter(ms, v -> v.value() == 7.0)); Assertions.assertEquals(1, out.size()); Assertions.assertEquals(out.get(0).id().tags(), ArrayTagSet.create(t)); }
@Test public void keepAnyTag() { PrototypeMeasurementFilter.TagFilterPattern pattern = new PrototypeMeasurementFilter.TagFilterPattern( new PrototypeMeasurementFilterSpecification.TagFilterSpecification("", "")); Tag tagA = new BasicTag("some_name_value", "some_value_string"); Assertions.assertTrue(pattern.test(tagA)); }
@Test public void tag() { Id id = new Builder() .withTag(new BasicTag("k", "v")) .build(); Assertions.assertEquals(newId("k", "v"), id); }
@Test public void testCreateIdArray() { Registry r = newRegistry(true, 10000); Id id1 = r.createId("foo", "bar", "baz", "k", "v"); Id id2 = r.createId("foo", ArrayTagSet.create("k", "v").add(new BasicTag("bar", "baz"))); Assertions.assertEquals(id1, id2); }
@Test public void firstTag() { List<Measurement> ms = newList(10); Tag t = new BasicTag("i", "7"); Measurement m = Utils.first(ms, t); Assertions.assertEquals(m.id().tags(), ArrayTagSet.create(t)); }
@Test public void testTimerHelpers() { Registry r = newRegistry(true, 10000); Timer c1 = r.timer("foo", "bar", "baz", "k", "v"); Timer c2 = r.timer("foo", ArrayTagSet.create("k", "v").add(new BasicTag("bar", "baz"))); Timer c3 = r.timer("foo"); Assertions.assertSame(unwrap(c1), unwrap(c2)); Assertions.assertNotSame(unwrap(c1), unwrap(c3)); }