method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
PrometheusNamingConvention implements NamingConvention { @Override public String tagKey(String key) { String conventionKey = NamingConvention.snakeCase.tagKey(key); String sanitized = tagKeyChars.matcher(conventionKey).replaceAll("_"); if (!Character.isLetter(sanitized.charAt(0))) { sanitized = "m_" + sanitized; } return sanitized; } PrometheusNamingConvention(); PrometheusNamingConvention(String timerSuffix); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); }### Answer:
@Test void formatTagKey() { assertThat(convention.tagKey("123abc/{:id}水")).startsWith("m_123abc___id__"); } |
### Question:
KairosMeterRegistry extends StepMeterRegistry { Stream<String> writeGauge(Gauge gauge) { double value = gauge.value(); if (Double.isFinite(value)) { return Stream.of(writeMetric(gauge.getId(), config().clock().wallTime(), value)); } return Stream.empty(); } @SuppressWarnings("deprecation") KairosMeterRegistry(KairosConfig config, Clock clock); private KairosMeterRegistry(KairosConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(KairosConfig config); }### Answer:
@Test void writeGauge() { meterRegistry.gauge("my.gauge", 1d); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).hasSize(1); }
@Test void writeGaugeShouldDropNanValue() { meterRegistry.gauge("my.gauge", Double.NaN); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); }
@Test void writeGaugeShouldDropInfiniteValues() { meterRegistry.gauge("my.gauge", Double.POSITIVE_INFINITY); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); meterRegistry.gauge("my.gauge", Double.NEGATIVE_INFINITY); gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); } |
### Question:
KairosMeterRegistry extends StepMeterRegistry { Stream<String> writeFunctionCounter(FunctionCounter counter) { double count = counter.count(); if (Double.isFinite(count)) { return Stream.of(writeMetric(counter.getId(), config().clock().wallTime(), count)); } return Stream.empty(); } @SuppressWarnings("deprecation") KairosMeterRegistry(KairosConfig config, Clock clock); private KairosMeterRegistry(KairosConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(KairosConfig config); }### Answer:
@Test void writeFunctionCounter() { FunctionCounter counter = FunctionCounter.builder("myCounter", 1d, Number::doubleValue).register(meterRegistry); clock.add(config.step()); assertThat(meterRegistry.writeFunctionCounter(counter)).hasSize(1); } |
### Question:
KairosNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return format(delegate.name(name, type, baseUnit)); } KairosNamingConvention(); KairosNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void defaultToSnakeCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE)).isEqualTo("gauge_size"); } |
### Question:
EtsyStatsdLineBuilder extends FlavorStatsdLineBuilder { @Override String line(String amount, @Nullable Statistic stat, String type) { updateIfNamingConventionChanged(); return nameByStatistic(stat) + ":" + amount + "|" + type; } EtsyStatsdLineBuilder(Meter.Id id, MeterRegistry.Config config, HierarchicalNameMapper nameMapper); }### Answer:
@Test void changingNamingConvention() { Counter c = registry.counter("my.counter", "my.tag", "value"); EtsyStatsdLineBuilder lb = new EtsyStatsdLineBuilder(c.getId(), registry.config(), HierarchicalNameMapper.DEFAULT); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my.counter.my.tag.value.statistic.count:1|c"); registry.config().namingConvention(NamingConvention.camelCase); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("myCounter.myTag.value.statistic.count:1|c"); }
@Issue("#739") @Test void sanitizeColons() { Counter c = registry.counter("my:counter", "my:tag", "my:value"); EtsyStatsdLineBuilder lb = new EtsyStatsdLineBuilder(c.getId(), registry.config(), HierarchicalNameMapper.DEFAULT); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my_counter.my_tag.my_value.statistic.count:1|c"); } |
### Question:
TelegrafStatsdLineBuilder extends FlavorStatsdLineBuilder { @Override String line(String amount, @Nullable Statistic stat, String type) { updateIfNamingConventionChanged(); return name + tagsByStatistic(stat) + ":" + amount + "|" + type; } TelegrafStatsdLineBuilder(Meter.Id id, MeterRegistry.Config config); }### Answer:
@Test void changingNamingConvention() { Counter c = registry.counter("my.counter", "my.tag", "value"); TelegrafStatsdLineBuilder lb = new TelegrafStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my.counter,statistic=count,my.tag=value:1|c"); registry.config().namingConvention(NamingConvention.camelCase); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("myCounter,statistic=count,myTag=value:1|c"); }
@Issue("#739") @Test void sanitizeColons() { Counter c = registry.counter("my:counter", "my:tag", "my:value"); TelegrafStatsdLineBuilder lb = new TelegrafStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my_counter,statistic=count,my_tag=my_value:1|c"); } |
### Question:
NewRelicNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return StringEscapeUtils.escapeJson(toValidNewRelicString(delegate.name(name, type, baseUnit))); } NewRelicNamingConvention(); NewRelicNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void name() { String validString = newRelicNamingConvention.name(VALID_NAME, Type.COUNTER); assertThat(validString).isEqualTo(VALID_NAME); }
@Test void nameShouldStripInvalidCharacters() { String validString = newRelicNamingConvention.name(INVALID_NAME, Type.COUNTER); assertThat(validString).isEqualTo("invalid_name"); } |
### Question:
StatsdMeterRegistry extends MeterRegistry { public void stop() { if (started.compareAndSet(true, false)) { if (statsdConnection.get() != null) { statsdConnection.get().dispose(); } if (meterPoller.get() != null) { meterPoller.get().dispose(); } } } StatsdMeterRegistry(StatsdConfig config, Clock clock); StatsdMeterRegistry(StatsdConfig config, HierarchicalNameMapper nameMapper, Clock clock); private StatsdMeterRegistry(StatsdConfig config,
HierarchicalNameMapper nameMapper,
NamingConvention namingConvention,
Clock clock,
@Nullable Function<Meter.Id, StatsdLineBuilder> lineBuilderFunction,
@Nullable Consumer<String> lineSink); static Builder builder(StatsdConfig config); void start(); void stop(); @Override void close(); @Deprecated int queueSize(); @Deprecated int queueCapacity(); }### Answer:
@Test void interactWithStoppedRegistry() { registry = new StatsdMeterRegistry(configWithFlavor(StatsdFlavor.ETSY), clock); registry.stop(); registry.counter("my.counter").increment(); } |
### Question:
StatsdGauge extends AbstractMeter implements Gauge, StatsdPollable { @Override public void poll() { double val = value(); if (Double.isFinite(val) && (alwaysPublish || lastValue.getAndSet(val) != val)) { sink.next(lineBuilder.gauge(val)); } } StatsdGauge(Id id, StatsdLineBuilder lineBuilder, FluxSink<String> sink, @Nullable T obj, ToDoubleFunction<T> value, boolean alwaysPublish); @Override double value(); @Override void poll(); @SuppressWarnings("EqualsWhichDoesntCheckParameterClass") @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test void shouldAlwaysPublishValue() { AtomicInteger lines = new AtomicInteger(0); MeterRegistry registry = StatsdMeterRegistry.builder(StatsdConfig.DEFAULT) .lineSink(l -> lines.incrementAndGet()) .build(); StatsdGauge<?> alwaysPublishingGauge = (StatsdGauge<?>) Gauge .builder("test", value, AtomicInteger::get).register(registry); alwaysPublishingGauge.poll(); alwaysPublishingGauge.poll(); assertThat(lines.get()).isEqualTo(2); }
@Test void shouldOnlyPublishValueWhenValueChanges() { AtomicInteger lines = new AtomicInteger(0); MeterRegistry registry = StatsdMeterRegistry .builder(new StatsdConfig() { @Override public String get(String key) { return null; } @Override public boolean publishUnchangedMeters() { return false; } }) .lineSink(l -> lines.incrementAndGet()) .build(); StatsdGauge<?> gaugePublishingOnChange = (StatsdGauge<?>) Gauge .builder("test", value, AtomicInteger::get).register(registry); gaugePublishingOnChange.poll(); gaugePublishingOnChange.poll(); assertThat(lines.get()).isEqualTo(1); value.incrementAndGet(); gaugePublishingOnChange.poll(); assertThat(lines.get()).isEqualTo(2); } |
### Question:
InfluxNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return escape(delegate.name(name, type, baseUnit).replace("=", "_")); } InfluxNamingConvention(); InfluxNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Issue("#693") @Test void name() { assertThat(convention.name("foo.bar=, baz", Meter.Type.GAUGE)).isEqualTo("foo_bar_\\,\\ baz"); } |
### Question:
InfluxNamingConvention implements NamingConvention { @Override public String tagKey(String key) { if (key.equals("time")) { throw new IllegalArgumentException("'time' is an invalid tag key in InfluxDB"); } return escape(delegate.tagKey(key)); } InfluxNamingConvention(); InfluxNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagKey() { assertThat(convention.tagKey("foo.bar=, baz")).isEqualTo("foo_bar\\=\\,\\ baz"); }
@Test void timeCannotBeATagKey() { assertThat(catchThrowable(() -> convention.tagKey("time"))).isInstanceOf(IllegalArgumentException.class); } |
### Question:
InfluxNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return escape(this.delegate.tagValue(value).replace('\n', ' ')); } InfluxNamingConvention(); InfluxNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagValue() { assertThat(convention.tagValue("foo=, bar")).isEqualTo("foo\\=\\,\\ bar"); }
@Test void timeCanBeATagValue() { assertThat(convention.tagValue("time")).isEqualTo("time"); }
@Issue("#645") @Test void namingConventionIsNotAppliedToTagValues() { assertThat(convention.tagValue("org.example.service=")).isEqualTo("org.example.service\\="); }
@Issue("#2155") @Test void newlineCharReplacedInTagValues() { assertThat(convention.tagValue("hello\nworld\n")).isEqualTo("hello\\ world\\ "); } |
### Question:
CreateDatabaseQueryBuilder { String build() { StringBuilder queryStringBuilder = new StringBuilder(String.format(QUERY_MANDATORY_TEMPLATE, databaseName)); if (hasAnyRetentionPolicy()) { String retentionPolicyClause = Stream.of(retentionPolicyClauses).filter(Objects::nonNull) .reduce(RETENTION_POLICY_INTRODUCTION, String::concat); queryStringBuilder.append(retentionPolicyClause); } return queryStringBuilder.toString(); } CreateDatabaseQueryBuilder(String databaseName); }### Answer:
@Test void noRetentionPolicy() { String query = createDatabaseQueryBuilder.build(); assertEquals("CREATE DATABASE \"dummy_database_0\"", query); } |
### Question:
NewRelicNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return StringEscapeUtils.escapeJson(toValidNewRelicString(delegate.tagKey(key))); } NewRelicNamingConvention(); NewRelicNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagKey() { String validString = newRelicNamingConvention.tagKey(VALID_NAME); assertThat(validString).isEqualTo(VALID_NAME); }
@Test void tagKeyShouldStripInvalidCharacters() { String validString = newRelicNamingConvention.tagKey(INVALID_NAME); assertThat(validString).isEqualTo("invalid_name"); } |
### Question:
InfluxMeterRegistry extends StepMeterRegistry { Stream<String> writeFunctionTimer(FunctionTimer timer) { double sum = timer.totalTime(getBaseTimeUnit()); if (Double.isFinite(sum)) { Stream.Builder<Field> builder = Stream.builder(); builder.add(new Field("sum", sum)); builder.add(new Field("count", timer.count())); double mean = timer.mean(getBaseTimeUnit()); if (Double.isFinite(mean)) { builder.add(new Field("mean", mean)); } return Stream.of(influxLineProtocol(timer.getId(), "histogram", builder.build())); } return Stream.empty(); } @SuppressWarnings("deprecation") InfluxMeterRegistry(InfluxConfig config, Clock clock); @Deprecated InfluxMeterRegistry(InfluxConfig config, Clock clock, ThreadFactory threadFactory); private InfluxMeterRegistry(InfluxConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(InfluxConfig config); }### Answer:
@Test void nanMeanFunctionTimerShouldNotWriteMean() { FunctionTimer functionTimer = new FunctionTimer() { @Override public double count() { return 1; } @Override public double totalTime(TimeUnit unit) { return 1; } @Override public TimeUnit baseTimeUnit() { return TimeUnit.SECONDS; } @Override public Id getId() { return new Id("func.timer", Tags.empty(), null, null, Type.TIMER); } @Override public double mean(TimeUnit unit) { return Double.NaN; } }; assertThat(meterRegistry.writeFunctionTimer(functionTimer)) .containsOnly("func_timer,metric_type=histogram sum=1,count=1 1"); } |
### Question:
GraphiteHierarchicalNameMapper implements HierarchicalNameMapper { @Override public String toHierarchicalName(Meter.Id id, NamingConvention convention) { StringBuilder hierarchicalName = new StringBuilder(); for (String tagKey : tagsAsPrefix) { String tagValue = id.getTag(tagKey); if (tagValue != null) { hierarchicalName.append(convention.tagValue(tagValue)).append("."); } } hierarchicalName.append(id.getConventionName(convention)); for (Tag tag : id.getTagsAsIterable()) { if (!tagsAsPrefix.contains(tag.getKey())) { hierarchicalName.append('.').append(convention.tagKey(tag.getKey())) .append('.').append(convention.tagValue(tag.getValue())); } } return hierarchicalName.toString(); } GraphiteHierarchicalNameMapper(String... tagsAsPrefix); @Override String toHierarchicalName(Meter.Id id, NamingConvention convention); }### Answer:
@Issue("#561") @Test void tagsAsPrefix() { assertThat(nameMapper.toHierarchicalName(id, NamingConvention.camelCase)) .isEqualTo("PROD.MYAPP.myName.otherTag.value"); }
@Test void toHierarchicalNameShouldSanitizeTagValueFromTagsAsPrefix() { Meter.Id id = new SimpleMeterRegistry().counter("my.name", "app.name", "MY APP", "stack", "PROD", "other.tag", "value").getId(); assertThat(nameMapper.toHierarchicalName(id, new GraphiteHierarchicalNamingConvention())) .isEqualTo("PROD.MY_APP.myName.otherTag.value"); } |
### Question:
GraphiteHierarchicalNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return sanitizeName(this.delegate.name(normalize(name), type, baseUnit)); } GraphiteHierarchicalNamingConvention(); GraphiteHierarchicalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void name() { assertThat(convention.name("name([{id}])/1", Meter.Type.TIMER)).isEqualTo("name___id____1"); }
@Test void dotNotationIsConvertedToCamelCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE)).isEqualTo("gaugeSize"); }
@Test void nameShouldPreserveDot() { GraphiteHierarchicalNamingConvention convention = new GraphiteHierarchicalNamingConvention(NamingConvention.identity); assertThat(convention.name("my.counter", Meter.Type.COUNTER)).isEqualTo("my.counter"); }
@Test void nameShouldSanitizeSpace() { assertThat(convention.name("counter 1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeQuestionMark() { assertThat(convention.name("counter?1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeColon() { assertThat(convention.name("counter:1", Meter.Type.COUNTER)).isEqualTo("counter_1"); } |
### Question:
GraphiteHierarchicalNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return sanitizeTag(this.delegate.tagKey(normalize(key))); } GraphiteHierarchicalNamingConvention(); GraphiteHierarchicalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagKeyShouldSanitizeDot() { GraphiteHierarchicalNamingConvention convention = new GraphiteHierarchicalNamingConvention(NamingConvention.identity); assertThat(convention.tagKey("my.tag")).isEqualTo("my_tag"); }
@Test void tagKeyShouldSanitizeSpace() { assertThat(convention.tagKey("tag 1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeQuestionMark() { assertThat(convention.tagKey("tag?1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeColon() { assertThat(convention.tagKey("tag:1")).isEqualTo("tag_1"); }
@Test void tagValueShouldSanitizeSpace() { assertThat(convention.tagKey("value 1")).isEqualTo("value_1"); }
@Test void tagValueShouldSanitizeQuestionMark() { assertThat(convention.tagKey("value?1")).isEqualTo("value_1"); }
@Test void tagValueShouldSanitizeColon() { assertThat(convention.tagKey("value:1")).isEqualTo("value_1"); } |
### Question:
GraphiteHierarchicalNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return sanitizeTag(this.delegate.tagValue(normalize(value))); } GraphiteHierarchicalNamingConvention(); GraphiteHierarchicalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagValueShouldSanitizeDot() { assertThat(convention.tagValue("my.value")).isEqualTo("my_value"); } |
### Question:
NewRelicNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return StringEscapeUtils.escapeJson(delegate.tagValue(value)); } NewRelicNamingConvention(); NewRelicNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagValue() { String validString = newRelicNamingConvention.tagValue(VALID_NAME); assertThat(validString).isEqualTo(VALID_NAME); }
@Test void tagValueShouldNotStripInvalidCharacters() { String validString = newRelicNamingConvention.tagValue(INVALID_NAME); assertThat(validString).isEqualTo(INVALID_NAME); } |
### Question:
GraphiteDimensionalNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return sanitizeName(this.delegate.name(normalize(name), type, baseUnit)); } GraphiteDimensionalNamingConvention(); GraphiteDimensionalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void name() { assertThat(convention.name("name([{id}])/1", Meter.Type.TIMER)).isEqualTo("name___id____1"); }
@Test void nameShouldPreserveDot() { assertThat(convention.name("my.counter", Meter.Type.COUNTER)).isEqualTo("my.counter"); }
@Test void nameShouldSanitizeSpace() { assertThat(convention.name("counter 1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeQuestionMark() { assertThat(convention.name("counter?1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeSemiColon() { assertThat(convention.name("counter;1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeColon() { assertThat(convention.name("counter:1", Meter.Type.COUNTER)).isEqualTo("counter_1"); } |
### Question:
GraphiteDimensionalNamingConvention implements NamingConvention { @Override public String tagKey(String key) { if (key.isEmpty()) { return UNSPECIFIED; } return sanitizeTagKey(this.delegate.tagKey(normalize(key))); } GraphiteDimensionalNamingConvention(); GraphiteDimensionalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagKeyShouldPreserveDot() { assertThat(convention.tagKey("my.tag")).isEqualTo("my.tag"); }
@Test void tagKeyShouldPreserveSpace() { assertThat(convention.tagKey("tag 1")).isEqualTo("tag 1"); }
@Test void tagKeyShouldPreserveQuestionMark() { assertThat(convention.tagKey("tag?1")).isEqualTo("tag?1"); }
@Test void tagKeyShouldPreserveColon() { assertThat(convention.tagKey("tag:1")).isEqualTo("tag:1"); }
@Test void tagKeyShouldSanitizeSemiColon() { assertThat(convention.tagKey("tag;1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeExclamation() { assertThat(convention.tagKey("tag!1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeCarat() { assertThat(convention.tagKey("tag^1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeEquals() { assertThat(convention.tagKey("tag=1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldPreserveTilde() { assertThat(convention.tagKey("tag~1")).isEqualTo("tag~1"); }
@Test void tagKeyShouldHaveLengthGreaterThanZero() { assertThat(convention.tagKey("")).isEqualTo("unspecified"); } |
### Question:
GraphiteDimensionalNamingConvention implements NamingConvention { @Override public String tagValue(String value) { if (value.isEmpty()) { return UNSPECIFIED; } return sanitizeTagValue(this.delegate.tagValue(normalize(value))); } GraphiteDimensionalNamingConvention(); GraphiteDimensionalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagValueShouldPreserveDot() { assertThat(convention.tagValue("my.tag")).isEqualTo("my.tag"); }
@Test void tagValueShouldPreserveSpace() { assertThat(convention.tagValue("tag 1")).isEqualTo("tag 1"); }
@Test void tagValueShouldPreserveQuestionMark() { assertThat(convention.tagValue("tag?1")).isEqualTo("tag?1"); }
@Test void tagValueShouldPreserveColon() { assertThat(convention.tagValue("tag:1")).isEqualTo("tag:1"); }
@Test void tagValueShouldSanitizeSemiColon() { assertThat(convention.tagValue("tag;1")).isEqualTo("tag_1"); }
@Test void tagValueShouldPreserveExclamation() { assertThat(convention.tagValue("tag!1")).isEqualTo("tag!1"); }
@Test void tagValueShouldPreserveCarat() { assertThat(convention.tagValue("tag^1")).isEqualTo("tag^1"); }
@Test void tagValueShouldPreserveEquals() { assertThat(convention.tagValue("tag=1")).isEqualTo("tag=1"); }
@Test void tagValueShouldSanitizeTilde() { assertThat(convention.tagValue("tag~1")).isEqualTo("tag_1"); }
@Test void tagValueShouldHaveLengthGreaterThanZero() { assertThat(convention.tagValue("")).isEqualTo("unspecified"); } |
### Question:
OpenTSDBMeterRegistry extends PushMeterRegistry { Stream<String> writeGauge(Gauge gauge) { double value = gauge.value(); if (Double.isFinite(value)) { return Stream.of(writeMetric(gauge.getId(), config().clock().wallTime(), value)); } return Stream.empty(); } @SuppressWarnings("deprecation") OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock); OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(OpenTSDBConfig config); @Override Counter newCounter(Meter.Id id); @Override DistributionSummary newDistributionSummary(Meter.Id id, DistributionStatisticConfig distributionStatisticConfig, double scale); }### Answer:
@Test void writeGauge() { meterRegistry.gauge("my.gauge", 1d); Gauge gauge = meterRegistry.get("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).hasSize(1); }
@Test void writeGaugeShouldDropNanValue() { meterRegistry.gauge("my.gauge", Double.NaN); Gauge gauge = meterRegistry.get("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); }
@Test void writeGaugeShouldDropInfiniteValues() { meterRegistry.gauge("my.gauge", Double.POSITIVE_INFINITY); Gauge gauge = meterRegistry.get("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); meterRegistry.gauge("my.gauge", Double.NEGATIVE_INFINITY); gauge = meterRegistry.get("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); } |
### Question:
CloudWatchUtils { static double clampMetricValue(double value) { if (Double.isNaN(value)) { return value; } double magnitude = Math.abs(value); if (magnitude == 0) { return 0; } double clampedMag = Math.min(Math.max(magnitude, MINIMUM_ALLOWED_VALUE), MAXIMUM_ALLOWED_VALUE); return Math.copySign(clampedMag, value); } private CloudWatchUtils(); }### Answer:
@Test void testClamp() { assertThat(CloudWatchUtils.clampMetricValue(Double.NaN)) .as("Check NaN") .isNaN(); assertThat(CloudWatchUtils.clampMetricValue(Double.MIN_VALUE)) .as("Check minimum value") .isEqualTo(EXPECTED_MIN); assertThat(CloudWatchUtils.clampMetricValue(Double.NEGATIVE_INFINITY)) .as("Check negative infinity") .isEqualTo(-EXPECTED_MAX); assertThat(CloudWatchUtils.clampMetricValue(Double.POSITIVE_INFINITY)) .as("Check positive infinity") .isEqualTo(EXPECTED_MAX); assertThat(CloudWatchUtils.clampMetricValue(-Double.MAX_VALUE)) .as("Check negative max value") .isEqualTo(-EXPECTED_MAX); assertThat(CloudWatchUtils.clampMetricValue(0)) .as("Check 0") .isEqualTo(0); assertThat(CloudWatchUtils.clampMetricValue(-0)) .as("Check -0") .isEqualTo(0); assertThat(CloudWatchUtils.clampMetricValue(100.1)) .as("Check positive value") .isEqualTo(100.1); assertThat(CloudWatchUtils.clampMetricValue(-10.2)) .as("Check negative value") .isEqualTo(-10.2); } |
### Question:
CloudWatchNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return StringUtils.truncate(delegate.tagKey(key), MAX_TAG_KEY_LENGTH); } CloudWatchNamingConvention(); CloudWatchNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void truncateTagKey() { assertThat(namingConvention.tagKey(repeat("x", 256))).hasSize(255); } |
### Question:
CloudWatchNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return StringUtils.truncate(delegate.tagValue(value), MAX_TAG_VALUE_LENGTH); } CloudWatchNamingConvention(); CloudWatchNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void truncateTagValue() { assertThat(namingConvention.tagValue(repeat("x", 256))).hasSize(255); } |
### Question:
HumioNamingConvention implements NamingConvention { @Override public String tagKey(String key) { if (key.equals("name")) { key = "name.tag"; } return delegate.tagKey(key); } HumioNamingConvention(); HumioNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); }### Answer:
@Test void replaceNameTag() { assertThat(namingConvention.tagKey("name")).isEqualTo("name_tag"); } |
### Question:
DatadogMetricMetadata { String editMetadataBody() { if (descriptionsEnabled && id.getDescription() != null) { String body = "{\"type\":\"" + type + "\""; String baseUnit = sanitizeBaseUnit(id.getBaseUnit(), overrideBaseUnit); if (baseUnit != null) { body += ",\"unit\":\"" + baseUnit + "\""; } body += ",\"description\":\"" + StringEscapeUtils.escapeJson(id.getDescription()) + "\"}"; return body; } return null; } DatadogMetricMetadata(Meter.Id id, Statistic statistic, boolean descriptionsEnabled,
@Nullable String overrideBaseUnit); }### Answer:
@Test void escapesStringsInDescription() { DatadogMetricMetadata metricMetadata = new DatadogMetricMetadata( Counter.builder("name") .tag("key", "value") .description("The /\"recent cpu usage\" for the Java Virtual Machine process") .register(new SimpleMeterRegistry()).getId(), Statistic.COUNT, true, null ); assertThat(metricMetadata.editMetadataBody()).isEqualTo("{\"type\":\"count\",\"description\":\"The /\\\"recent cpu usage\\\" for the Java Virtual Machine process\"}"); }
@Test void unitsAreConverted() { DatadogMetricMetadata metricMetadata = new DatadogMetricMetadata( Timer.builder("name") .tag("key", "value") .description("Time spent in GC pause") .register(new DatadogMeterRegistry(new DatadogConfig() { @Override public String apiKey() { return "fake"; } @Override public String get(String key) { return null; } }, Clock.SYSTEM)).getId(), Statistic.TOTAL_TIME, false, null); assertThat(metricMetadata.editMetadataBody()).isNull(); } |
### Question:
DatadogNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { String sanitized = StringEscapeUtils.escapeJson(delegate.name(name, type, baseUnit) .replace('/', '_')); if (!Character.isLetter(sanitized.charAt(0))) { sanitized = "m." + sanitized; } return StringUtils.truncate(sanitized, MAX_NAME_LENGTH); } DatadogNamingConvention(); DatadogNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void nameStartsWithLetter() { assertThat(convention.name("123", Meter.Type.GAUGE, null)).isEqualTo("m.123"); }
@Test void dotNotationIsConvertedToCamelCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE, null)).isEqualTo("gauge.size"); } |
### Question:
DatadogNamingConvention implements NamingConvention { @Override public String tagKey(String key) { String sanitized = StringEscapeUtils.escapeJson(delegate.tagKey(key)); if (Character.isDigit(sanitized.charAt(0))) { sanitized = "m." + sanitized; } return sanitized; } DatadogNamingConvention(); DatadogNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagKeyStartsWithLetter() { assertThat(convention.tagKey("123")).isEqualTo("m.123"); }
@Test void tagKeyWhenStartsWithNumberShouldRespectDelegateNamingConvention() { String tagKey = "123"; NamingConvention delegate = new NamingConvention() { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return name; } @Override public String tagKey(String key) { return "123456"; } }; assertThat(delegate.tagKey(tagKey)).isEqualTo("123456"); DatadogNamingConvention convention = new DatadogNamingConvention(delegate); assertThat(convention.tagKey(tagKey)).isEqualTo("m.123456"); } |
### Question:
WavefrontNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { String sanitizedName = NAME_CLEANUP_PATTERN.matcher(delegate.name(name, type, baseUnit)).replaceAll("_"); if (namePrefix != null) { return namePrefix + "." + sanitizedName; } return sanitizedName; } WavefrontNamingConvention(@Nullable String namePrefix); WavefrontNamingConvention(@Nullable String namePrefix, NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void name() { assertThat(convention.name("123abc/{:id}水", Meter.Type.GAUGE)).isEqualTo("123abc/__id__"); } |
### Question:
WavefrontNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return KEY_CLEANUP_PATTERN.matcher(delegate.tagKey(key)).replaceAll("_"); } WavefrontNamingConvention(@Nullable String namePrefix); WavefrontNamingConvention(@Nullable String namePrefix, NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagKey() { assertThat(convention.tagKey("123abc/{:id}水")).isEqualTo("123abc___id__"); } |
### Question:
WavefrontNamingConvention implements NamingConvention { @Override public String tagValue(String value) { String sanitized = delegate.tagValue(value); return StringEscapeUtils.escapeJson(sanitized.endsWith("\\") ? sanitized.substring(0, sanitized.length() - 1) + "_" : sanitized); } WavefrontNamingConvention(@Nullable String namePrefix); WavefrontNamingConvention(@Nullable String namePrefix, NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagValue() { assertThat(convention.tagValue("123abc/\"{:id}水\\")).isEqualTo("123abc/\\\"{:id}水_"); assertThat(convention.tagValue("\\")).isEqualTo("_"); } |
### Question:
WavefrontMeterRegistry extends PushMeterRegistry { void publishMetric(Meter.Id id, @Nullable String suffix, long wallTime, double value) { if (!Double.isFinite(value)) { return; } Meter.Id fullId = id; if (suffix != null) { fullId = idWithSuffix(id, suffix); } String name = getConventionName(fullId); String source = config.source(); Map<String, String> tags = getTagsAsMap(id); try { wavefrontSender.sendMetric(name, value, wallTime, source, tags); } catch (IOException e) { logger.warn("failed to report metric to Wavefront: " + fullId.getName(), e); } } WavefrontMeterRegistry(WavefrontConfig config, Clock clock); @Deprecated WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory); WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory,
WavefrontSender wavefrontSender); static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config); static Builder builder(WavefrontConfig config); }### Answer:
@Test void publishMetric() throws IOException { Meter.Id id = registry.counter("name").getId(); long time = System.currentTimeMillis(); registry.publishMetric(id, null, System.currentTimeMillis(), 1d); verify(wavefrontSender, times(1)).sendMetric("name", 1d, time, "host", Collections.emptyMap()); verifyNoMoreInteractions(wavefrontSender); }
@Test void publishMetricWhenNanOrInfinityShouldNotAdd() { Meter.Id id = registry.counter("name").getId(); registry.publishMetric(id, null, System.currentTimeMillis(), Double.NaN); registry.publishMetric(id, null, System.currentTimeMillis(), Double.POSITIVE_INFINITY); verifyNoInteractions(wavefrontSender); } |
### Question:
WavefrontMeterRegistry extends PushMeterRegistry { void publishDistribution(Meter.Id id, List<WavefrontHistogramImpl.Distribution> distributions) { String name = getConventionName(id); String source = config.source(); Map<String, String> tags = getTagsAsMap(id); for (WavefrontHistogramImpl.Distribution distribution : distributions) { try { wavefrontSender.sendDistribution(name, distribution.centroids, histogramGranularities, distribution.timestamp, source, tags); } catch (IOException e) { logger.warn("failed to send distribution to Wavefront: " + id.getName(), e); } } } WavefrontMeterRegistry(WavefrontConfig config, Clock clock); @Deprecated WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory); WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory,
WavefrontSender wavefrontSender); static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config); static Builder builder(WavefrontConfig config); }### Answer:
@Test void publishDistribution() throws IOException { Meter.Id id = registry.summary("name").getId(); long time = System.currentTimeMillis(); List<Pair<Double, Integer>> centroids = Arrays.asList(new Pair<>(1d, 1)); List<WavefrontHistogramImpl.Distribution> distributions = Arrays.asList( new WavefrontHistogramImpl.Distribution(time, centroids) ); registry.publishDistribution(id, distributions); verify(wavefrontSender, times(1)).sendDistribution("name", centroids, Collections.singleton(HistogramGranularity.MINUTE), time, "host", Collections.emptyMap()); verifyNoMoreInteractions(wavefrontSender); } |
### Question:
WavefrontMeterRegistry extends PushMeterRegistry { static String getWavefrontReportingUri(WavefrontConfig wavefrontConfig) { if (!isDirectToApi(wavefrontConfig)) { return "http" + wavefrontConfig.uri().substring("proxy".length()); } return wavefrontConfig.uri(); } WavefrontMeterRegistry(WavefrontConfig config, Clock clock); @Deprecated WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory); WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory,
WavefrontSender wavefrontSender); static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config); static Builder builder(WavefrontConfig config); }### Answer:
@Test void proxyUriConvertedToHttp() { assertThat(WavefrontMeterRegistry.getWavefrontReportingUri(WavefrontConfig.DEFAULT_PROXY)).startsWith("http: }
@Test void directApiUriUnchanged() { assertThat(WavefrontMeterRegistry.getWavefrontReportingUri(WavefrontConfig.DEFAULT_DIRECT)).isEqualTo(WavefrontConfig.DEFAULT_DIRECT.uri()); } |
### Question:
GangliaMeterRegistry extends StepMeterRegistry { String getMetricName(Meter.Id id, @Nullable String suffix) { return nameMapper.toHierarchicalName(id.withName(suffix != null ? id.getName() + "." + suffix : id.getName()), config().namingConvention()); } GangliaMeterRegistry(GangliaConfig config, Clock clock); @Deprecated GangliaMeterRegistry(GangliaConfig config, Clock clock, HierarchicalNameMapper nameMapper); private GangliaMeterRegistry(GangliaConfig config, Clock clock, HierarchicalNameMapper nameMapper, ThreadFactory threadFactory); @SuppressWarnings("unused") @Deprecated GangliaMeterRegistry(GangliaConfig config, Clock clock, HierarchicalNameMapper nameMapper, MetricRegistry metricRegistry); static Builder builder(GangliaConfig config); }### Answer:
@Test void getMetricNameWhenSuffixIsNullShouldNotAppendSuffix() { Meter.Id id = registry.counter("name").getId(); assertThat(registry.getMetricName(id, null)).isEqualTo("name"); }
@Test void getMetricNameWhenSuffixIsNotNullShouldAppendSuffix() { Meter.Id id = registry.counter("name").getId(); assertThat(registry.getMetricName(id, "suffix")).isEqualTo("nameSuffix"); } |
### Question:
StackdriverNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return sanitize(nameDelegate.name(name, type, baseUnit), NAME_BLACKLIST, MAX_NAME_LENGTH); } StackdriverNamingConvention(); StackdriverNamingConvention(NamingConvention nameDelegate, NamingConvention tagKeyDelegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void name() { assertThat(namingConvention.name("my.counter", Meter.Type.COUNTER)).isEqualTo("my/counter"); } |
### Question:
StackdriverNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return sanitize(tagKeyDelegate.tagKey(key), TAG_KEY_BLACKLIST, MAX_TAG_KEY_LENGTH); } StackdriverNamingConvention(); StackdriverNamingConvention(NamingConvention nameDelegate, NamingConvention tagKeyDelegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }### Answer:
@Test void tagKey() { assertThat(namingConvention.tagKey("my.tag")).isEqualTo("my_tag"); } |
### Question:
AzureMonitorMeterRegistry extends StepMeterRegistry { public static Builder builder(AzureMonitorConfig config) { return new Builder(config); } AzureMonitorMeterRegistry(AzureMonitorConfig config, Clock clock); private AzureMonitorMeterRegistry(AzureMonitorConfig config, Clock clock,
TelemetryConfiguration telemetryConfiguration,
ThreadFactory threadFactory); static Builder builder(AzureMonitorConfig config); @Override void close(); }### Answer:
@Test void useTelemetryConfigInstrumentationKeyWhenSet() { TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.createDefault(); telemetryConfiguration.setInstrumentationKey("fake"); AzureMonitorMeterRegistry.builder(new AzureMonitorConfig() { @Override public String get(String key) { return null; } @Override public String instrumentationKey() { return "other"; } }).telemetryConfiguration(telemetryConfiguration).build(); assertThat(telemetryConfiguration.getInstrumentationKey()).isEqualTo("fake"); }
@Test void failWhenTelemetryConfigInstrumentationKeyIsUnsetAndConfigInstrumentationKeyIsNull() { TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.createDefault(); assertThatExceptionOfType(ValidationException.class) .isThrownBy(() -> AzureMonitorMeterRegistry.builder(key -> null) .telemetryConfiguration(telemetryConfiguration).build()); } |
### Question:
AzureMonitorNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return NAME_AND_TAG_KEY_PATTERN.matcher(delegate.name(name, type, baseUnit)).replaceAll("_"); } AzureMonitorNamingConvention(); AzureMonitorNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); }### Answer:
@Test void testNameContainsDesiredCharacters() { assertThat(namingConvention.name("{[email protected]}", Type.GAUGE)).isEqualTo("_custom_Metric_1_"); } |
### Question:
AzureMonitorNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return NAME_AND_TAG_KEY_PATTERN.matcher(delegate.tagKey(key)).replaceAll("_"); } AzureMonitorNamingConvention(); AzureMonitorNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); }### Answer:
@Test void testTagKeyContainsDesiredCharacters() { assertThat(namingConvention.tagKey("Pc.N@me")).isEqualTo("Pc_N_me"); } |
### Question:
StringUtils { public static String truncate(String string, int maxLength) { if (string.length() > maxLength) { return string.substring(0, maxLength); } return string; } private StringUtils(); static boolean isBlank(@Nullable String string); static boolean isNotBlank(@Nullable String string); static boolean isEmpty(@Nullable String string); static boolean isNotEmpty(@Nullable String string); static String truncate(String string, int maxLength); }### Answer:
@Test void truncateWhenGreaterThanMaxLengthShouldTruncate() { assertThat(StringUtils.truncate("1234567890", 5)).isEqualTo("12345"); }
@Test void truncateWhenLessThanMaxLengthShouldReturnItself() { assertThat(StringUtils.truncate("123", 5)).isEqualTo("123"); } |
### Question:
OpenTSDBMeterRegistry extends PushMeterRegistry { Stream<String> writeFunctionCounter(FunctionCounter counter) { double count = counter.count(); if (Double.isFinite(count)) { return Stream.of(writeMetric(counter.getId(), config().clock().wallTime(), count)); } return Stream.empty(); } @SuppressWarnings("deprecation") OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock); OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(OpenTSDBConfig config); @Override Counter newCounter(Meter.Id id); @Override DistributionSummary newDistributionSummary(Meter.Id id, DistributionStatisticConfig distributionStatisticConfig, double scale); }### Answer:
@Test void writeFunctionCounter() { FunctionCounter counter = FunctionCounter.builder("my.counter", 1d, Number::doubleValue).register(meterRegistry); clock.add(config.step()); assertThat(meterRegistry.writeFunctionCounter(counter)).hasSize(1); } |
### Question:
StringUtils { public static boolean isNotEmpty(@Nullable String string) { return !isEmpty(string); } private StringUtils(); static boolean isBlank(@Nullable String string); static boolean isNotBlank(@Nullable String string); static boolean isEmpty(@Nullable String string); static boolean isNotEmpty(@Nullable String string); static String truncate(String string, int maxLength); }### Answer:
@Test void isNotEmptyWhenNullShouldBeFalse() { assertThat(StringUtils.isNotEmpty(null)).isFalse(); }
@Test void isNotEmptyWhenEmptyShouldBeFalse() { assertThat(StringUtils.isNotEmpty("")).isFalse(); }
@Test void isNotEmptyWhenHasAnyCharacterShouldBeFalse() { assertThat(StringUtils.isNotEmpty(" ")).isTrue(); } |
### Question:
TimeUtils { public static String format(Duration duration) { return duration.toString() .substring(2) .replaceAll("(\\d[HMS])(?!$)", "$1 ") .toLowerCase(); } private TimeUtils(); static double convert(double t, TimeUnit sourceUnit, TimeUnit destinationUnit); static double nanosToUnit(double nanos, TimeUnit destinationUnit); static double microsToUnit(double micros, TimeUnit destinationUnit); static double millisToUnit(double millis, TimeUnit destinationUnit); static double secondsToUnit(double seconds, TimeUnit destinationUnit); static double minutesToUnit(double minutes, TimeUnit destinationUnit); static double hoursToUnit(double hours, TimeUnit destinationUnit); static double daysToUnit(double days, TimeUnit destinationUnit); @Deprecated static Duration simpleParse(String time); static String format(Duration duration); }### Answer:
@Test void formatDuration() { assertThat(TimeUtils.format(Duration.ofSeconds(10))).isEqualTo("10s"); assertThat(TimeUtils.format(Duration.ofSeconds(90))).isEqualTo("1m 30s"); assertThat(TimeUtils.format(Duration.ofMinutes(2))).isEqualTo("2m"); assertThat(TimeUtils.format(Duration.ofNanos(1001234000000L))).isEqualTo("16m 41.234s"); } |
### Question:
StringEscapeUtils { public static String escapeJson(@Nullable String v) { if (v == null) return ""; int length = v.length(); if (length == 0) return v; int afterReplacement = 0; StringBuilder builder = null; for (int i = 0; i < length; i++) { char c = v.charAt(i); String replacement; if (c < 0x80) { replacement = REPLACEMENT_CHARS[c]; if (replacement == null) continue; } else if (c == '\u2028') { replacement = U2028; } else if (c == '\u2029') { replacement = U2029; } else { continue; } if (afterReplacement < i) { if (builder == null) builder = new StringBuilder(length); builder.append(v, afterReplacement, i); } if (builder == null) builder = new StringBuilder(length); builder.append(replacement); afterReplacement = i + 1; } if (builder == null) return v; if (afterReplacement < length) { builder.append(v, afterReplacement, length); } return builder.toString(); } private StringEscapeUtils(); static String escapeJson(@Nullable String v); }### Answer:
@Test void escapeJsonWhenNullShouldReturnEmptyString() { assertThat(StringEscapeUtils.escapeJson(null)).isEmpty(); }
@Test void escapeJsonWhenEmptyStringShouldReturnEmptyString() { assertThat(StringEscapeUtils.escapeJson("")).isEmpty(); }
@Test void escapeJsonWhenDoubleQuotesShouldReturnEscapedString() { assertThat(StringEscapeUtils.escapeJson("\"Hello, world!\"")).isEqualTo("\\\"Hello, world!\\\""); } |
### Question:
OpenTSDBNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { String conventionName = NamingConvention.snakeCase.name(name, type, baseUnit); switch (type) { case COUNTER: case DISTRIBUTION_SUMMARY: case GAUGE: if (baseUnit != null && !conventionName.endsWith("_" + baseUnit)) conventionName += "_" + baseUnit; break; } switch (type) { case COUNTER: if (!conventionName.endsWith("_total")) conventionName += "_total"; break; case TIMER: case LONG_TASK_TIMER: if (conventionName.endsWith(timerSuffix)) { conventionName += "_seconds"; } else if (!conventionName.endsWith("_seconds")) conventionName += timerSuffix + "_seconds"; break; } String sanitized = nameChars.matcher(conventionName).replaceAll(SEPARATOR); if (!Character.isLetter(sanitized.charAt(0))) { sanitized = "m_" + sanitized; } return sanitized; } OpenTSDBNamingConvention(); OpenTSDBNamingConvention(String timerSuffix); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); }### Answer:
@Test void defaultToSnakeCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE)).isEqualTo("gauge_size"); } |
### Question:
AbstractPartition extends AbstractList<List<T>> { @Override public List<T> get(int index) { int start = index * partitionSize; int end = Math.min(start + partitionSize, delegate.size()); return delegate.subList(start, end); } protected AbstractPartition(List<T> delegate, int partitionSize); @Override List<T> get(int index); @Override int size(); @Override boolean isEmpty(); }### Answer:
@Test void singlePartitionListActsLikeDelegate_singleElement() { TestPartition singlePartition = new TestPartition(asList("foo"), 1); assertThat(singlePartition).hasSize(1); assertThat(singlePartition.get(0)).containsExactly("foo"); }
@Test void singlePartitionListActsLikeDelegate_multipleElements() { TestPartition singlePartition = new TestPartition(asList("foo", "bar"), 2); assertThat(singlePartition).hasSize(1); assertThat(singlePartition.get(0)).containsExactly("foo", "bar"); }
@Test void lessElementsThanPartitionSize() { TestPartition partition = new TestPartition(asList("foo", "bar"), 3); assertThat(partition).hasSize(1); assertThat(partition.get(0)).containsExactly("foo", "bar"); } |
### Question:
AbstractPartition extends AbstractList<List<T>> { static <T> int partitionCount(List<T> delegate, int partitionSize) { int result = delegate.size() / partitionSize; return delegate.size() % partitionSize == 0 ? result : result + 1; } protected AbstractPartition(List<T> delegate, int partitionSize); @Override List<T> get(int index); @Override int size(); @Override boolean isEmpty(); }### Answer:
@Test void partitionCount_roundsUp() { assertThat(partitionCount(asList("foo", "bar", "baz"), 2)) .isEqualTo(2); } |
### Question:
NamedThreadFactory implements ThreadFactory { @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r); int seq = sequence.getAndIncrement(); thread.setName(prefix + (seq > 1 ? "-" + seq : "")); if (!thread.isDaemon()) thread.setDaemon(true); return thread; } NamedThreadFactory(String prefix); @Override Thread newThread(Runnable r); }### Answer:
@Test void nameThreads() { NamedThreadFactory threadFactory = new NamedThreadFactory("name"); Runnable body = () -> { }; assertThat(threadFactory.newThread(body).getName()).isEqualTo("name"); assertThat(threadFactory.newThread(body).getName()).isEqualTo("name-2"); } |
### Question:
IOUtils { public static String toString(@Nullable InputStream inputStream, Charset charset) { if (inputStream == null) return ""; try (StringWriter writer = new StringWriter(); InputStreamReader reader = new InputStreamReader(inputStream, charset); BufferedReader bufferedReader = new BufferedReader(reader)) { char[] chars = new char[DEFAULT_BUFFER_SIZE]; int readChars; while ((readChars = bufferedReader.read(chars)) != EOF) { writer.write(chars, 0, readChars); } return writer.toString(); } catch (IOException ex) { throw new UncheckedIOException(ex); } } private IOUtils(); static String toString(@Nullable InputStream inputStream, Charset charset); static String toString(@Nullable InputStream inputStream); }### Answer:
@Test void testToString() { String expected = "This is a sample."; ByteArrayInputStream inputStream = new ByteArrayInputStream(expected.getBytes()); assertThat(IOUtils.toString(inputStream)).isEqualTo(expected); }
@Test void testToStringWithCharset() { String expected = "This is a sample."; ByteArrayInputStream inputStream = new ByteArrayInputStream(expected.getBytes(StandardCharsets.UTF_8)); assertThat(IOUtils.toString(inputStream, StandardCharsets.UTF_8)).isEqualTo(expected); } |
### Question:
DoubleFormat { public static String decimalOrNan(double d) { return DECIMAL_OR_NAN.get().format(d); } private DoubleFormat(); static String decimalOrNan(double d); @Deprecated static String decimalOrWhole(double d); static String decimal(double d); static String wholeOrDecimal(double d); }### Answer:
@Test void decimalOrNan() { assertThat(DoubleFormat.decimalOrNan(Double.NaN)).isEqualTo("NaN"); assertThat(DoubleFormat.decimalOrNan(123456.1234567)).isEqualTo("123456.123457"); assertThat(DoubleFormat.decimalOrNan(123456)).isEqualTo("123456"); assertThat(DoubleFormat.decimalOrNan(0.123)).isEqualTo("0.123"); } |
### Question:
DoubleFormat { public static String wholeOrDecimal(double d) { return WHOLE_OR_DECIMAL.get().format(d); } private DoubleFormat(); static String decimalOrNan(double d); @Deprecated static String decimalOrWhole(double d); static String decimal(double d); static String wholeOrDecimal(double d); }### Answer:
@Test void wholeOrDecimal() { assertThat(DoubleFormat.wholeOrDecimal(123456.1234567)).isEqualTo("123456.123457"); assertThat(DoubleFormat.wholeOrDecimal(1)).isEqualTo("1"); } |
### Question:
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeTimer(Timer timer) { return Optional.of(writeDocument(timer, builder -> { builder.append(",\"count\":").append(timer.count()); builder.append(",\"sum\":").append(timer.totalTime(getBaseTimeUnit())); builder.append(",\"mean\":").append(timer.mean(getBaseTimeUnit())); builder.append(",\"max\":").append(timer.max(getBaseTimeUnit())); })); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }### Answer:
@Test void writeTimer() { Timer timer = Timer.builder("myTimer").register(registry); assertThat(registry.writeTimer(timer)).contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"myTimer\",\"type\":\"timer\",\"count\":0,\"sum\":0.0,\"mean\":0.0,\"max\":0.0}"); } |
### Question:
DoubleFormat { public static String decimal(double d) { return DECIMAL.get().format(d); } private DoubleFormat(); static String decimalOrNan(double d); @Deprecated static String decimalOrWhole(double d); static String decimal(double d); static String wholeOrDecimal(double d); }### Answer:
@Test void decimal() { assertThat(DoubleFormat.decimal(123456.1234567)).isEqualTo("123456.123457"); assertThat(DoubleFormat.decimal(123456)).isEqualTo("123456.0"); assertThat(DoubleFormat.decimal(0.123)).isEqualTo("0.123"); } |
### Question:
CumulativeFunctionTimer implements FunctionTimer { public double totalTime(TimeUnit unit) { T obj2 = ref.get(); if (obj2 != null) { lastTime = Math.max(TimeUtils.convert(totalTimeFunction.applyAsDouble(obj2), totalTimeFunctionUnit, baseTimeUnit()), 0); } return TimeUtils.convert(lastTime, baseTimeUnit(), unit); } CumulativeFunctionTimer(Id id, T obj, ToLongFunction<T> countFunction, ToDoubleFunction<T> totalTimeFunction,
TimeUnit totalTimeFunctionUnit, TimeUnit baseTimeUnit); double count(); double totalTime(TimeUnit unit); @Override Id getId(); @Override TimeUnit baseTimeUnit(); Type type(); }### Answer:
@Test void totalTimeWhenStateObjectChangedToNullShouldWorkWithChangedTimeUnit() { CumulativeFunctionTimer<Object> functionTimer = new CumulativeFunctionTimer<>( null, new Object(), (o) -> 1L, (o) -> 1d, TimeUnit.SECONDS, TimeUnit.SECONDS); assertThat(functionTimer.totalTime(TimeUnit.SECONDS)).isEqualTo(1d); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1000d); System.gc(); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1000d); assertThat(functionTimer.totalTime(TimeUnit.SECONDS)).isEqualTo(1d); } |
### Question:
MeterRegistry { @Incubating(since = "1.2.0") public void clear() { meterMap.keySet().forEach(this::remove); } protected MeterRegistry(Clock clock); List<Meter> getMeters(); void forEachMeter(Consumer<? super Meter> consumer); Config config(); Search find(String name); RequiredSearch get(String name); Counter counter(String name, Iterable<Tag> tags); Counter counter(String name, String... tags); DistributionSummary summary(String name, Iterable<Tag> tags); DistributionSummary summary(String name, String... tags); Timer timer(String name, Iterable<Tag> tags); Timer timer(String name, String... tags); More more(); @Nullable T gauge(String name, Iterable<Tag> tags, @Nullable T stateObject, ToDoubleFunction<T> valueFunction); @Nullable T gauge(String name, Iterable<Tag> tags, T number); @Nullable T gauge(String name, T number); @Nullable T gauge(String name, T stateObject, ToDoubleFunction<T> valueFunction); @Nullable T gaugeCollectionSize(String name, Iterable<Tag> tags, T collection); @Nullable T gaugeMapSize(String name, Iterable<Tag> tags, T map); @Incubating(since = "1.1.0") @Nullable Meter remove(Meter meter); @Incubating(since = "1.1.0") @Nullable Meter remove(Meter.Id mappedId); @Incubating(since = "1.2.0") void clear(); void close(); boolean isClosed(); }### Answer:
@Test void clear() { registry.counter("my.counter"); registry.counter("my.counter2"); assertThat(registry.find("my.counter").counter()).isNotNull(); assertThat(registry.find("my.counter2").counter()).isNotNull(); registry.clear(); assertThat(registry.find("my.counter").counter()).isNull(); assertThat(registry.find("my.counter2").counter()).isNull(); } |
### Question:
SimpleMeterRegistry extends MeterRegistry { @Override protected <T> FunctionTimer newFunctionTimer(Meter.Id id, T obj, ToLongFunction<T> countFunction, ToDoubleFunction<T> totalTimeFunction, TimeUnit totalTimeFunctionUnit) { switch (config.mode()) { case CUMULATIVE: return new CumulativeFunctionTimer<>(id, obj, countFunction, totalTimeFunction, totalTimeFunctionUnit, getBaseTimeUnit()); case STEP: default: return new StepFunctionTimer<>(id, clock, config.step().toMillis(), obj, countFunction, totalTimeFunction, totalTimeFunctionUnit, getBaseTimeUnit()); } } SimpleMeterRegistry(); SimpleMeterRegistry(SimpleConfig config, Clock clock); }### Answer:
@Test void newFunctionTimerWhenCountingModeIsCumulativeShouldReturnCumulativeFunctionTimer() { SimpleMeterRegistry registry = createRegistry(CountingMode.CUMULATIVE); Meter.Id id = new Meter.Id("some.timer", Tags.empty(), null, null, Meter.Type.TIMER); FunctionTimer functionTimer = registry.newFunctionTimer(id, null, (o) -> 0L, (o) -> 0d, TimeUnit.SECONDS); assertThat(functionTimer).isInstanceOf(CumulativeFunctionTimer.class); }
@Test void newFunctionTimerWhenCountingModeIsStepShouldReturnStepFunctionTimer() { SimpleMeterRegistry registry = createRegistry(CountingMode.STEP); Meter.Id id = new Meter.Id("some.timer", Tags.empty(), null, null, Meter.Type.TIMER); FunctionTimer functionTimer = registry.newFunctionTimer(id, null, (o) -> 0L, (o) -> 0d, TimeUnit.SECONDS); assertThat(functionTimer).isInstanceOf(StepFunctionTimer.class); } |
### Question:
SimpleMeterRegistry extends MeterRegistry { @Override protected <T> FunctionCounter newFunctionCounter(Meter.Id id, T obj, ToDoubleFunction<T> countFunction) { switch (config.mode()) { case CUMULATIVE: return new CumulativeFunctionCounter<>(id, obj, countFunction); case STEP: default: return new StepFunctionCounter<>(id, clock, config.step().toMillis(), obj, countFunction); } } SimpleMeterRegistry(); SimpleMeterRegistry(SimpleConfig config, Clock clock); }### Answer:
@Test void newFunctionCounterWhenCountingModeIsCumulativeShouldReturnCumulativeFunctionCounter() { SimpleMeterRegistry registry = createRegistry(CountingMode.CUMULATIVE); Meter.Id id = new Meter.Id("some.timer", Tags.empty(), null, null, Meter.Type.COUNTER); FunctionCounter functionCounter = registry.newFunctionCounter(id, null, (o) -> 0d); assertThat(functionCounter).isInstanceOf(CumulativeFunctionCounter.class); }
@Test void newFunctionCounterWhenCountingModeIsStepShouldReturnStepFunctionCounter() { SimpleMeterRegistry registry = createRegistry(CountingMode.STEP); Meter.Id id = new Meter.Id("some.timer", Tags.empty(), null, null, Meter.Type.COUNTER); FunctionCounter functionCounter = registry.newFunctionCounter(id, null, (o) -> 0d); assertThat(functionCounter).isInstanceOf(StepFunctionCounter.class); } |
### Question:
DropwizardFunctionTimer extends AbstractMeter implements FunctionTimer { @Override public double totalTime(TimeUnit unit) { T obj2 = ref.get(); if (obj2 != null) { lastTime = TimeUtils.convert(totalTimeFunction.applyAsDouble(obj2), totalTimeFunctionUnit, baseTimeUnit()); } return TimeUtils.convert(lastTime, baseTimeUnit(), unit); } DropwizardFunctionTimer(Meter.Id id, Clock clock,
T obj, ToLongFunction<T> countFunction,
ToDoubleFunction<T> totalTimeFunction,
TimeUnit totalTimeFunctionUnit,
TimeUnit registryBaseTimeUnit); Timer getDropwizardMeter(); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }### Answer:
@Test void totalTimeWhenStateObjectChangedToNullShouldWorkWithChangedTimeUnit() { DropwizardFunctionTimer<Object> functionTimer = new DropwizardFunctionTimer<>( null, new MockClock(), new Object(), (o) -> 1L, (o) -> 1d, TimeUnit.SECONDS, TimeUnit.SECONDS); assertThat(functionTimer.totalTime(TimeUnit.SECONDS)).isEqualTo(1d); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1000d); System.gc(); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1000d); assertThat(functionTimer.totalTime(TimeUnit.SECONDS)).isEqualTo(1d); } |
### Question:
DropwizardFunctionTimer extends AbstractMeter implements FunctionTimer { public Timer getDropwizardMeter() { return dropwizardMeter; } DropwizardFunctionTimer(Meter.Id id, Clock clock,
T obj, ToLongFunction<T> countFunction,
ToDoubleFunction<T> totalTimeFunction,
TimeUnit totalTimeFunctionUnit,
TimeUnit registryBaseTimeUnit); Timer getDropwizardMeter(); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }### Answer:
@Test void getDropwizardMeterGetSnapshotGetMeanShouldReturnNanoseconds() { DropwizardFunctionTimer<Object> functionTimer = new DropwizardFunctionTimer<>( null, new MockClock(), new Object(), (o) -> 1L, (o) -> 1d, TimeUnit.SECONDS, TimeUnit.SECONDS); assertThat(functionTimer.getDropwizardMeter().getSnapshot().getMean()).isEqualTo(1000_000_000d); } |
### Question:
DropwizardMeterRegistry extends MeterRegistry { public MetricRegistry getDropwizardRegistry() { return registry; } DropwizardMeterRegistry(DropwizardConfig config, MetricRegistry registry, HierarchicalNameMapper nameMapper, Clock clock); MetricRegistry getDropwizardRegistry(); }### Answer:
@Issue("#1038") @Test void removeShouldWork() { Counter counter = registry.counter("test"); assertThat(registry.getDropwizardRegistry().getMeters()).hasSize(1); registry.remove(counter); assertThat(registry.getDropwizardRegistry().getMeters()).isEmpty(); } |
### Question:
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeCounter(Counter counter) { return writeCounter(counter, counter.count()); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }### Answer:
@Test void writeCounter() { Counter counter = Counter.builder("myCounter").register(registry); counter.increment(); clock.add(config.step()); assertThat(registry.writeCounter(counter)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:01:00.001Z\",\"name\":\"myCounter\",\"type\":\"counter\",\"count\":1.0}"); } |
### Question:
Metrics { public static Counter counter(String name, Iterable<Tag> tags) { return globalRegistry.counter(name, tags); } static void addRegistry(MeterRegistry registry); static void removeRegistry(MeterRegistry registry); static Counter counter(String name, Iterable<Tag> tags); static Counter counter(String name, String... tags); static DistributionSummary summary(String name, Iterable<Tag> tags); static DistributionSummary summary(String name, String... tags); static Timer timer(String name, Iterable<Tag> tags); static Timer timer(String name, String... tags); static More more(); @Nullable static T gauge(String name, Iterable<Tag> tags, T obj, ToDoubleFunction<T> valueFunction); @Nullable static T gauge(String name, Iterable<Tag> tags, T number); @Nullable static T gauge(String name, T number); @Nullable static T gauge(String name, T obj, ToDoubleFunction<T> valueFunction); @Nullable static T gaugeCollectionSize(String name, Iterable<Tag> tags, T collection); @Nullable static T gaugeMapSize(String name, Iterable<Tag> tags, T map); static final CompositeMeterRegistry globalRegistry; }### Answer:
@Test void staticMetricsAreInitiallyNoop() { Metrics.counter("counter").increment(); } |
### Question:
LoggingMeterRegistry extends StepMeterRegistry { private Function<Meter, String> defaultMeterIdPrinter() { return (meter) -> getConventionName(meter.getId()) + getConventionTags(meter.getId()).stream() .map(t -> t.getKey() + "=" + t.getValue()) .collect(joining(",", "{", "}")); } LoggingMeterRegistry(); LoggingMeterRegistry(LoggingRegistryConfig config, Clock clock); private LoggingMeterRegistry(LoggingRegistryConfig config, Clock clock, ThreadFactory threadFactory, Consumer<String> loggingSink, @Nullable Function<Meter, String> meterIdPrinter); static Builder builder(LoggingRegistryConfig config); }### Answer:
@Test void defaultMeterIdPrinter() { LoggingMeterRegistry registry = LoggingMeterRegistry.builder(LoggingRegistryConfig.DEFAULT) .build(); Counter counter = registry.counter("my.gauage", "tag-1", "tag-2"); LoggingMeterRegistry.Printer printer = registry.new Printer(counter); assertThat(printer.id()).isEqualTo("my.gauage{tag-1=tag-2}"); } |
### Question:
LoggingMeterRegistry extends StepMeterRegistry { public static Builder builder(LoggingRegistryConfig config) { return new Builder(config); } LoggingMeterRegistry(); LoggingMeterRegistry(LoggingRegistryConfig config, Clock clock); private LoggingMeterRegistry(LoggingRegistryConfig config, Clock clock, ThreadFactory threadFactory, Consumer<String> loggingSink, @Nullable Function<Meter, String> meterIdPrinter); static Builder builder(LoggingRegistryConfig config); }### Answer:
@Test void customMeterIdPrinter() { LoggingMeterRegistry registry = LoggingMeterRegistry.builder(LoggingRegistryConfig.DEFAULT) .meterIdPrinter(meter -> meter.getId().getName()) .build(); Counter counter = registry.counter("my.gauage", "tag-1", "tag-2"); LoggingMeterRegistry.Printer printer = registry.new Printer(counter); assertThat(printer.id()).isEqualTo("my.gauage"); }
@Test void humanReadableByteCount() { LoggingMeterRegistry.Printer printer = registry.new Printer(DistributionSummary.builder("my.summary") .baseUnit(BaseUnits.BYTES) .register(registry)); assertThat(printer.humanReadableBaseUnit(Double.NaN)).isEqualTo("NaN B"); assertThat(printer.humanReadableBaseUnit(1.0)).isEqualTo("1 B"); assertThat(printer.humanReadableBaseUnit(1024)).isEqualTo("1 KiB"); assertThat(printer.humanReadableBaseUnit(1024 * 1024 * 2.5678976654)).isEqualTo("2.567898 MiB"); }
@Test void otherUnit() { LoggingMeterRegistry.Printer printer = registry.new Printer(DistributionSummary.builder("my.summary") .baseUnit("things") .register(registry)); assertThat(printer.humanReadableBaseUnit(1.0)).isEqualTo("1 things"); assertThat(printer.humanReadableBaseUnit(1024)).isEqualTo("1024 things"); } |
### Question:
NoopGauge extends NoopMeter implements Gauge { @Override public double value() { return 0; } NoopGauge(Id id); @Override double value(); }### Answer:
@Test void returnsValueAsZero() { assertThat(gauge.value()).isEqualTo(0d); } |
### Question:
NoopLongTaskTimer extends NoopMeter implements LongTaskTimer { @Override public Sample start() { return new NoopSample(); } NoopLongTaskTimer(Id id); @Override Sample start(); @Override double duration(TimeUnit unit); @Override int activeTasks(); @Override double max(TimeUnit unit); @Override HistogramSnapshot takeSnapshot(); @Override TimeUnit baseTimeUnit(); }### Answer:
@Test void returnsStart() { assertThat(timer.start()).isNotNull(); } |
### Question:
NoopLongTaskTimer extends NoopMeter implements LongTaskTimer { @Override public double duration(TimeUnit unit) { return 0; } NoopLongTaskTimer(Id id); @Override Sample start(); @Override double duration(TimeUnit unit); @Override int activeTasks(); @Override double max(TimeUnit unit); @Override HistogramSnapshot takeSnapshot(); @Override TimeUnit baseTimeUnit(); }### Answer:
@Test void returnsDuration() { assertThat(timer.duration(TimeUnit.MINUTES)).isEqualTo(0); } |
### Question:
NoopLongTaskTimer extends NoopMeter implements LongTaskTimer { @Override public int activeTasks() { return 0; } NoopLongTaskTimer(Id id); @Override Sample start(); @Override double duration(TimeUnit unit); @Override int activeTasks(); @Override double max(TimeUnit unit); @Override HistogramSnapshot takeSnapshot(); @Override TimeUnit baseTimeUnit(); }### Answer:
@Test void returnsActiveTasks() { assertThat(timer.activeTasks()).isEqualTo(0); } |
### Question:
NoopFunctionTimer extends NoopMeter implements FunctionTimer { @Override public double count() { return 0; } NoopFunctionTimer(Id id); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }### Answer:
@Test void returnsCountAsZero() { assertThat(timer.count()).isEqualTo(0d); } |
### Question:
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeFunctionCounter(FunctionCounter counter) { return writeCounter(counter, counter.count()); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }### Answer:
@Test void writeFunctionCounter() { FunctionCounter counter = FunctionCounter.builder("myCounter", 123.0, Number::doubleValue).register(registry); clock.add(config.step()); assertThat(registry.writeFunctionCounter(counter)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:01:00.001Z\",\"name\":\"myCounter\",\"type\":\"counter\",\"count\":123.0}"); } |
### Question:
SignalFxMeterRegistry extends StepMeterRegistry { Stream<SignalFxProtocolBuffers.DataPoint.Builder> addLongTaskTimer(LongTaskTimer longTaskTimer) { return Stream.of( addDatapoint(longTaskTimer, GAUGE, "activeTasks", longTaskTimer.activeTasks()), addDatapoint(longTaskTimer, COUNTER, "duration", longTaskTimer.duration(getBaseTimeUnit())) ); } SignalFxMeterRegistry(SignalFxConfig config, Clock clock); SignalFxMeterRegistry(SignalFxConfig config, Clock clock, ThreadFactory threadFactory); }### Answer:
@Test void addLongTaskTimer() { LongTaskTimer longTaskTimer = LongTaskTimer.builder("my.long.task.timer").register(this.registry); assertThat(this.registry.addLongTaskTimer(longTaskTimer)).hasSize(2); } |
### Question:
NoopFunctionTimer extends NoopMeter implements FunctionTimer { @Override public double totalTime(TimeUnit unit) { return 0; } NoopFunctionTimer(Id id); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }### Answer:
@Test void returnsTotalTimeAsZero() { assertThat(timer.totalTime(TimeUnit.NANOSECONDS)).isEqualTo(0d); } |
### Question:
NoopFunctionTimer extends NoopMeter implements FunctionTimer { @Override public TimeUnit baseTimeUnit() { return TimeUnit.NANOSECONDS; } NoopFunctionTimer(Id id); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }### Answer:
@Test void returnsNanosAsTimeUnit() { assertThat(timer.baseTimeUnit()).isEqualTo(TimeUnit.NANOSECONDS); } |
### Question:
NoopTimer extends NoopMeter implements Timer { @Override public void record(long amount, TimeUnit unit) { } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void recordSupplier() { String expectedResult = "value"; Supplier<String> supplier = () -> expectedResult; assertThat(timer.record(supplier)).isEqualTo(expectedResult); }
@Test void recordRunnable() { Runnable runnable = mock(Runnable.class); timer.record(runnable); verify(runnable).run(); } |
### Question:
NoopTimer extends NoopMeter implements Timer { @Override public <T> T recordCallable(Callable<T> f) throws Exception { return f.call(); } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void recordCallable() throws Exception { String expectedResult = "value"; Callable<String> callable = () -> expectedResult; assertThat(timer.recordCallable(callable)).isEqualTo(expectedResult); } |
### Question:
NoopTimer extends NoopMeter implements Timer { @Override public long count() { return 0; } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void returnsCountAsZero() { assertThat(timer.count()).isEqualTo(0L); } |
### Question:
NoopTimer extends NoopMeter implements Timer { @Override public double totalTime(TimeUnit unit) { return 0; } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void returnsTotalTimeAsZero() { assertThat(timer.totalTime(TimeUnit.SECONDS)).isEqualTo(0L); } |
### Question:
NoopTimer extends NoopMeter implements Timer { @Override public double max(TimeUnit unit) { return 0; } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void returnsMaxAsZero() { assertThat(timer.max(TimeUnit.SECONDS)).isEqualTo(0L); } |
### Question:
NoopTimer extends NoopMeter implements Timer { @Override public TimeUnit baseTimeUnit() { return TimeUnit.SECONDS; } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void returnsBaseTimeUnit() { assertThat(timer.baseTimeUnit()).isEqualTo(TimeUnit.SECONDS); } |
### Question:
NoopDistributionSummary extends NoopMeter implements DistributionSummary { @Override public long count() { return 0; } NoopDistributionSummary(Id id); @Override void record(double amount); @Override long count(); @Override double totalAmount(); @Override double max(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void returnsCountAsZero() { assertThat(distributionSummary.count()).isEqualTo(0L); } |
### Question:
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeGauge(Gauge gauge) { double value = gauge.value(); if (Double.isFinite(value)) { return Optional.of(writeDocument(gauge, builder -> { builder.append(",\"value\":").append(value); })); } return Optional.empty(); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }### Answer:
@Test void writeGauge() { Gauge gauge = Gauge.builder("myGauge", 123.0, Number::doubleValue).register(registry); assertThat(registry.writeGauge(gauge)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"myGauge\",\"type\":\"gauge\",\"value\":123.0}"); } |
### Question:
NoopDistributionSummary extends NoopMeter implements DistributionSummary { @Override public double totalAmount() { return 0; } NoopDistributionSummary(Id id); @Override void record(double amount); @Override long count(); @Override double totalAmount(); @Override double max(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void returnsTotalAmountAsZero() { assertThat(distributionSummary.totalAmount()).isEqualTo(0L); } |
### Question:
NoopDistributionSummary extends NoopMeter implements DistributionSummary { @Override public double max() { return 0; } NoopDistributionSummary(Id id); @Override void record(double amount); @Override long count(); @Override double totalAmount(); @Override double max(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void returnsMaxAsZero() { assertThat(distributionSummary.max()).isEqualTo(0L); } |
### Question:
NoopCounter extends NoopMeter implements Counter { @Override public double count() { return 0; } NoopCounter(Id id); @Override void increment(double amount); @Override double count(); }### Answer:
@Test void returnsCountAsZero() { assertThat(counter.count()).isEqualTo(0L); } |
### Question:
NoopMeter extends AbstractMeter { @Override public List<Measurement> measure() { return emptyList(); } NoopMeter(Id id); @Override List<Measurement> measure(); }### Answer:
@Test void returnsMeasureAsEmptyList() { assertThat(meter.measure()).isEqualTo(Collections.emptyList()); } |
### Question:
NoopFunctionCounter extends NoopMeter implements FunctionCounter { @Override public double count() { return 0; } NoopFunctionCounter(Id id); @Override double count(); }### Answer:
@Test void returnsCountAsZero() { assertThat(counter.count()).isEqualTo(0L); } |
### Question:
NoopTimeGauge extends NoopMeter implements TimeGauge { @Override public double value() { return 0; } NoopTimeGauge(Id id); @Override TimeUnit baseTimeUnit(); @Override double value(); }### Answer:
@Test void returnsValueAsZero() { assertThat(timeGauge.value()).isEqualTo(0d); } |
### Question:
NoopTimeGauge extends NoopMeter implements TimeGauge { @Override public TimeUnit baseTimeUnit() { return TimeUnit.NANOSECONDS; } NoopTimeGauge(Id id); @Override TimeUnit baseTimeUnit(); @Override double value(); }### Answer:
@Test void returnsBaseTimeUnit() { assertThat(timeGauge.baseTimeUnit()).isEqualTo(TimeUnit.NANOSECONDS); } |
### Question:
Tags implements Iterable<Tag> { private void dedup() { int n = tags.length; if (n == 0 || n == 1) { last = n; return; } int j = 0; for (int i = 0; i < n - 1; i++) if (!tags[i].getKey().equals(tags[i + 1].getKey())) tags[j++] = tags[i]; tags[j++] = tags[n - 1]; last = j; } private Tags(Tag[] tags); Tags and(String key, String value); Tags and(@Nullable String... keyValues); Tags and(@Nullable Tag... tags); Tags and(@Nullable Iterable<? extends Tag> tags); @Override Iterator<Tag> iterator(); Stream<Tag> stream(); @Override int hashCode(); @Override boolean equals(@Nullable Object obj); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable Iterable<Tag> otherTags); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable String... keyValues); static Tags of(@Nullable Iterable<? extends Tag> tags); static Tags of(String key, String value); static Tags of(@Nullable String... keyValues); static Tags of(@Nullable Tag... tags); static Tags empty(); @Override String toString(); }### Answer:
@Test void dedup() { assertThat(Tags.of("k1", "v1", "k2", "v2")).containsExactly(Tag.of("k1", "v1"), Tag.of("k2", "v2")); assertThat(Tags.of("k1", "v1", "k1", "v2")).containsExactly(Tag.of("k1", "v2")); assertThat(Tags.of("k1", "v1", "k1", "v2", "k3", "v3")).containsExactly(Tag.of("k1", "v2"), Tag.of("k3", "v3")); assertThat(Tags.of("k1", "v1", "k2", "v2", "k2", "v3")).containsExactly(Tag.of("k1", "v1"), Tag.of("k2", "v3")); } |
### Question:
Tags implements Iterable<Tag> { public Stream<Tag> stream() { return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator(), Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.NONNULL | Spliterator.SORTED), false); } private Tags(Tag[] tags); Tags and(String key, String value); Tags and(@Nullable String... keyValues); Tags and(@Nullable Tag... tags); Tags and(@Nullable Iterable<? extends Tag> tags); @Override Iterator<Tag> iterator(); Stream<Tag> stream(); @Override int hashCode(); @Override boolean equals(@Nullable Object obj); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable Iterable<Tag> otherTags); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable String... keyValues); static Tags of(@Nullable Iterable<? extends Tag> tags); static Tags of(String key, String value); static Tags of(@Nullable String... keyValues); static Tags of(@Nullable Tag... tags); static Tags empty(); @Override String toString(); }### Answer:
@Test void stream() { Tags tags = Tags.of(Tag.of("k1", "v1"), Tag.of("k1", "v1"), Tag.of("k2", "v2")); assertThat(tags.stream()).hasSize(2); } |
### Question:
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeTimeGauge(TimeGauge gauge) { double value = gauge.value(getBaseTimeUnit()); if (Double.isFinite(value)) { return Optional.of(writeDocument(gauge, builder -> { builder.append(",\"value\":").append(value); })); } return Optional.empty(); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }### Answer:
@Test void writeTimeGauge() { TimeGauge gauge = TimeGauge.builder("myGauge", 123.0, TimeUnit.MILLISECONDS, Number::doubleValue).register(registry); assertThat(registry.writeTimeGauge(gauge)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"myGauge\",\"type\":\"gauge\",\"value\":123.0}"); } |
### Question:
CompositeCounter extends AbstractCompositeMeter<Counter> implements Counter { @Override public void increment(double amount) { forEachChild(c -> c.increment(amount)); } CompositeCounter(Meter.Id id); @Override void increment(double amount); @Override double count(); }### Answer:
@Test @Issue("#119") void increment() { SimpleMeterRegistry simple = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock()); CompositeMeterRegistry registry = new CompositeMeterRegistry(); registry.add(simple); registry.counter("counter").increment(2.0); assertThat(simple.get("counter").counter().count()).isEqualTo(2.0); } |
### Question:
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeLongTaskTimer(LongTaskTimer timer) { return Optional.of(writeDocument(timer, builder -> { builder.append(",\"activeTasks\":").append(timer.activeTasks()); builder.append(",\"duration\":").append(timer.duration(getBaseTimeUnit())); })); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }### Answer:
@Test void writeLongTaskTimer() { LongTaskTimer timer = LongTaskTimer.builder("longTaskTimer").register(registry); assertThat(registry.writeLongTaskTimer(timer)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"longTaskTimer\",\"type\":\"long_task_timer\",\"activeTasks\":0,\"duration\":0.0}"); } |
### Question:
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeSummary(DistributionSummary summary) { HistogramSnapshot histogramSnapshot = summary.takeSnapshot(); return Optional.of(writeDocument(summary, builder -> { builder.append(",\"count\":").append(histogramSnapshot.count()); builder.append(",\"sum\":").append(histogramSnapshot.total()); builder.append(",\"mean\":").append(histogramSnapshot.mean()); builder.append(",\"max\":").append(histogramSnapshot.max()); })); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }### Answer:
@Test void writeSummary() { DistributionSummary summary = DistributionSummary.builder("summary").register(registry); summary.record(123); summary.record(456); clock.add(config.step()); assertThat(registry.writeSummary(summary)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:01:00.001Z\",\"name\":\"summary\",\"type\":\"distribution_summary\",\"count\":2,\"sum\":579.0,\"mean\":289.5,\"max\":456.0}"); } |
### Question:
CompositeLongTaskTimer extends AbstractCompositeMeter<LongTaskTimer> implements LongTaskTimer { @Override public Sample start() { List<Sample> samples = new ArrayList<>(); forEachChild(ltt -> samples.add(ltt.start())); return new CompositeSample(samples); } CompositeLongTaskTimer(Meter.Id id, DistributionStatisticConfig distributionStatisticConfig); @Override Sample start(); @Override double duration(TimeUnit unit); @Override int activeTasks(); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }### Answer:
@Test void mapIdsToEachLongTaskTimerInComposite() { MockClock clock = new MockClock(); MeterRegistry s1 = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock); LongTaskTimer anotherTimer = s1.more().longTaskTimer("long.task"); LongTaskTimer.Sample anotherSample = anotherTimer.start(); clock.add(10, TimeUnit.NANOSECONDS); CompositeMeterRegistry registry = new CompositeMeterRegistry(clock); registry.add(s1); LongTaskTimer longTaskTimer = registry.more().longTaskTimer("long.task"); LongTaskTimer.Sample sample = longTaskTimer.start(); clock.add(100, TimeUnit.NANOSECONDS); assertThat(anotherSample.stop()).isEqualTo(110); assertThat(sample.stop()).isEqualTo(100); } |
### Question:
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeMeter(Meter meter) { Iterable<Measurement> measurements = meter.measure(); List<String> names = new ArrayList<>(); List<Double> values = new ArrayList<>(); for (Measurement measurement : measurements) { double value = measurement.getValue(); if (!Double.isFinite(value)) { continue; } names.add(measurement.getStatistic().getTagValueRepresentation()); values.add(value); } if (names.isEmpty()) { return Optional.empty(); } return Optional.of(writeDocument(meter, builder -> { for (int i = 0; i < names.size(); i++) { builder.append(",\"").append(names.get(i)).append("\":\"").append(values.get(i)).append("\""); } })); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }### Answer:
@Test void writeMeter() { Timer timer = Timer.builder("myTimer").register(registry); assertThat(registry.writeMeter(timer)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"myTimer\",\"type\":\"timer\",\"count\":\"0.0\",\"total\":\"0.0\",\"max\":\"0.0\"}"); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.