Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Assertions refactoring #1580

Merged
merged 52 commits into from
Dec 6, 2024
Merged
Changes from all commits
Commits
Show all changes
52 commits
Select commit Hold shift + click to select a range
c3deb51
New metrics validation framework fundamentals.
robsunday Nov 22, 2024
fcf2bf8
Spotless fixes
robsunday Nov 22, 2024
d833450
Improved check for not received metrics
robsunday Nov 25, 2024
8cb96ad
Cassandra integration test converted
robsunday Nov 25, 2024
f3bac7e
Fine tuning assertion messages.
robsunday Nov 25, 2024
c9eb0a7
ActiveMqIntegrationTest converted
robsunday Nov 25, 2024
2c85c38
Spotless fix
robsunday Nov 26, 2024
bd1947f
introduce 'register' API
SylvainJuge Nov 26, 2024
1e64f80
introduce dedicated assertThat for metrics
SylvainJuge Nov 26, 2024
f7c6373
refactor metrics verifier
SylvainJuge Nov 26, 2024
b10a340
add some javadoc & few comments
SylvainJuge Nov 26, 2024
65ddfb3
spotless & minor things
SylvainJuge Nov 26, 2024
db54835
add new assertion for attribute entries
SylvainJuge Nov 26, 2024
1bdf694
check for missing assertions
SylvainJuge Nov 26, 2024
9f8a394
verify attributes are checked in strict mode
SylvainJuge Nov 27, 2024
6fb7960
enhance datapoint attributes check
SylvainJuge Nov 27, 2024
a458c1c
comments, cleanup and inline a bit
SylvainJuge Nov 27, 2024
b9f054c
strict check avoids duplicate assertions
SylvainJuge Nov 28, 2024
cf72d19
remove obsolete comments in activemq yaml
SylvainJuge Nov 28, 2024
eab7c69
register -> add
SylvainJuge Nov 28, 2024
9c3390c
reformat
SylvainJuge Nov 28, 2024
9392780
refactor cassandra
SylvainJuge Nov 28, 2024
5ae735d
fix lint
SylvainJuge Nov 28, 2024
2c65318
refactor activemq
SylvainJuge Nov 28, 2024
a670561
refactor jvm metrics
SylvainJuge Nov 28, 2024
df09034
remove unused code
SylvainJuge Nov 28, 2024
06a968f
recycle assertions when we can
SylvainJuge Nov 28, 2024
0e5fd2c
Merge pull request #4 from SylvainJuge/assertions-refactoring-more
robsunday Nov 28, 2024
8062a96
Added some JavaDocs.
robsunday Nov 28, 2024
ba95efa
Merge branch 'main' into assertions-refactoring
robsunday Nov 29, 2024
4bed658
Cleanup
robsunday Nov 29, 2024
fddc5fc
Spotless fix
robsunday Nov 29, 2024
fd82042
Refactoring of data point attribute assertions
robsunday Dec 4, 2024
80994f2
Merge branch 'main' into assertions-refactoring
robsunday Dec 4, 2024
b26cf42
Coe review changes
robsunday Dec 4, 2024
0bf10f5
JavaDoc update
robsunday Dec 4, 2024
9f47ef6
JavaDoc update
robsunday Dec 4, 2024
2971ef7
Update jmx-scraper/src/integrationTest/java/io/opentelemetry/contrib/…
robsunday Dec 5, 2024
7d7e504
Code review changes
robsunday Dec 5, 2024
19f5d4c
Cleanup
robsunday Dec 5, 2024
6431feb
Additional comments added
robsunday Dec 5, 2024
ba0f900
add attribute matcher set class
SylvainJuge Dec 5, 2024
fdc64e3
remove equals/hashcode
SylvainJuge Dec 5, 2024
7754e3a
use AttributeMatcherSet for matching
SylvainJuge Dec 5, 2024
7b7f0d0
code cleanup
SylvainJuge Dec 5, 2024
cdf4c74
Merge branch 'assertions-refactoring' of github.com:robsunday/opentel…
SylvainJuge Dec 5, 2024
b170021
move set matching
SylvainJuge Dec 5, 2024
59a7dfc
inline conversion to map
SylvainJuge Dec 5, 2024
34b3ab3
reformat & cleanup
SylvainJuge Dec 5, 2024
45ba126
simplify matchesValue
SylvainJuge Dec 6, 2024
5e69a82
rename attribute set -> group
SylvainJuge Dec 6, 2024
dfe3af3
Merge pull request #6 from SylvainJuge/assertions-refactoring
robsunday Dec 6, 2024
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -0,0 +1,61 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/

package io.opentelemetry.contrib.jmxscraper.assertions;

import javax.annotation.Nullable;

/** Implements functionality of matching data point attributes. */
public class AttributeMatcher {
private final String attributeName;
@Nullable private final String attributeValue;

/**
* Create instance used to match data point attribute with any value.
*
* @param attributeName matched attribute name
*/
AttributeMatcher(String attributeName) {
this(attributeName, null);
}

/**
* Create instance used to match data point attribute with te same name and with the same value.
*
* @param attributeName attribute name
* @param attributeValue attribute value
*/
AttributeMatcher(String attributeName, @Nullable String attributeValue) {
this.attributeName = attributeName;
this.attributeValue = attributeValue;
}

/**
* Return name of data point attribute that this AttributeMatcher is supposed to match value with.
*
* @return name of validated attribute
*/
public String getAttributeName() {
return attributeName;
}

@Override
public String toString() {
return attributeValue == null
? '{' + attributeName + '}'
: '{' + attributeName + '=' + attributeValue + '}';
}

/**
* Verify if this matcher is matching provided attribute value. If this matcher holds null value
* then it is matching any attribute value.
*
* @param value a value to be matched
* @return true if this matcher is matching provided value, false otherwise.
*/
boolean matchesValue(String value) {
return attributeValue == null || attributeValue.equals(value);
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,60 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/

package io.opentelemetry.contrib.jmxscraper.assertions;

import java.util.Collection;
import java.util.Map;
import java.util.stream.Collectors;

/** Group of attribute matchers */
public class AttributeMatcherGroup {

// stored as a Map for easy lookup by name
private final Map<String, AttributeMatcher> matchers;

/**
* Constructor for a set of attribute matchers
*
* @param matchers collection of matchers to build a group from
* @throws IllegalStateException if there is any duplicate key
*/
AttributeMatcherGroup(Collection<AttributeMatcher> matchers) {
this.matchers =
matchers.stream().collect(Collectors.toMap(AttributeMatcher::getAttributeName, m -> m));
}

/**
* Checks if attributes match this attribute matcher group
*
* @param attributes attributes to check as map
* @return {@literal true} when the attributes match all attributes from this group
*/
public boolean matches(Map<String, String> attributes) {
if (attributes.size() != matchers.size()) {
return false;
}

for (Map.Entry<String, String> entry : attributes.entrySet()) {
AttributeMatcher matcher = matchers.get(entry.getKey());
if (matcher == null) {
// no matcher for this key: unexpected key
return false;
}

if (!matcher.matchesValue(entry.getValue())) {
// value does not match: unexpected value
return false;
}
}

return true;
}

@Override
public String toString() {
return matchers.values().toString();
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,53 @@
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/

package io.opentelemetry.contrib.jmxscraper.assertions;

import java.util.Arrays;

/**
* Utility class implementing convenience static methods to construct data point attribute matchers
* and sets of matchers.
*/
public class DataPointAttributes {
private DataPointAttributes() {}

/**
* Create instance of matcher that should be used to check if data point attribute with given name
* has value identical to the one provided as a parameter (exact match).
*
* @param name name of the data point attribute to check
* @param value expected value of checked data point attribute
* @return instance of matcher
*/
public static AttributeMatcher attribute(String name, String value) {
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

[minor] add javadoc to explain the differences between all those methods: exact match, match with any value (even if the method name is quite clear on the latter, but not on the first on the exact match here).

return new AttributeMatcher(name, value);
}

/**
* Create instance of matcher that should be used to check if data point attribute with given name
* exists. Any value of the attribute is considered as matching (any value match).
*
* @param name name of the data point attribute to check
* @return instance of matcher
*/
public static AttributeMatcher attributeWithAnyValue(String name) {
return new AttributeMatcher(name);
}

/**
* Creates a group of attribute matchers that should be used to verify data point attributes.
*
* @param attributes list of matchers to create group. It must contain matchers with unique names.
* @return group of attribute matchers
* @throws IllegalArgumentException if provided list contains two or more matchers with the same
* attribute name
* @see MetricAssert#hasDataPointsWithAttributes(AttributeMatcherGroup...) for detailed
* description off the algorithm used for matching
*/
public static AttributeMatcherGroup attributeGroup(AttributeMatcher... attributes) {
return new AttributeMatcherGroup(Arrays.asList(attributes));
}
}
Original file line number Diff line number Diff line change
@@ -5,13 +5,14 @@

package io.opentelemetry.contrib.jmxscraper.assertions;

import static io.opentelemetry.contrib.jmxscraper.assertions.DataPointAttributes.attributeGroup;

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import io.opentelemetry.proto.common.v1.KeyValue;
import io.opentelemetry.proto.metrics.v1.Metric;
import io.opentelemetry.proto.metrics.v1.NumberDataPoint;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
@@ -21,15 +22,13 @@
import org.assertj.core.api.AbstractAssert;
import org.assertj.core.internal.Integers;
import org.assertj.core.internal.Iterables;
import org.assertj.core.internal.Maps;
import org.assertj.core.internal.Objects;

public class MetricAssert extends AbstractAssert<MetricAssert, Metric> {

private static final Objects objects = Objects.instance();
private static final Iterables iterables = Iterables.instance();
private static final Integers integers = Integers.instance();
private static final Maps maps = Maps.instance();

private boolean strict;

@@ -59,7 +58,7 @@ private void strictCheck(
if (!strict) {
return;
}
String failMsgPrefix = expectedCheckStatus ? "duplicate" : "missing";
String failMsgPrefix = expectedCheckStatus ? "Missing" : "Duplicate";
info.description(
"%s assertion on %s for metric '%s'", failMsgPrefix, metricProperty, actual.getName());
objects.assertEqual(info, actualCheckStatus, expectedCheckStatus);
@@ -122,8 +121,8 @@ private MetricAssert hasSum(boolean monotonic) {
info.description("sum expected for metric '%s'", actual.getName());
objects.assertEqual(info, actual.hasSum(), true);

String prefix = monotonic ? "monotonic" : "non-monotonic";
info.description(prefix + " sum expected for metric '%s'", actual.getName());
String sumType = monotonic ? "monotonic" : "non-monotonic";
info.description("sum for metric '%s' is expected to be %s", actual.getName(), sumType);
objects.assertEqual(info, actual.getSum().getIsMonotonic(), monotonic);
return this;
}
@@ -156,6 +155,11 @@ public MetricAssert isUpDownCounter() {
return this;
}

/**
* Verifies that there is no attribute in any of data points.
*
* @return this
*/
@CanIgnoreReturnValue
public MetricAssert hasDataPointsWithoutAttributes() {
isNotNull();
@@ -195,6 +199,7 @@ private MetricAssert checkDataPoints(Consumer<List<NumberDataPoint>> listConsume
return this;
}

// TODO: To be removed and calls will be replaced with hasDataPointsWithAttributes()
@CanIgnoreReturnValue
public MetricAssert hasTypedDataPoints(Collection<String> types) {
return checkDataPoints(
@@ -229,102 +234,61 @@ private void dataPointsCommonCheck(List<NumberDataPoint> dataPoints) {
}

/**
* Verifies that all data points have all the expected attributes
* Verifies that all metric data points have the same expected one attribute
*
* @param attributes expected attributes
* @param expectedAttribute attribute matcher to validate data points attributes
* @return this
*/
@SafeVarargs
@CanIgnoreReturnValue
public final MetricAssert hasDataPointsAttributes(Map.Entry<String, String>... attributes) {
return checkDataPoints(
dataPoints -> {
dataPointsCommonCheck(dataPoints);

Map<String, String> attributesMap = new HashMap<>();
for (Map.Entry<String, String> attributeEntry : attributes) {
attributesMap.put(attributeEntry.getKey(), attributeEntry.getValue());
}
for (NumberDataPoint dataPoint : dataPoints) {
Map<String, String> dataPointAttributes = toMap(dataPoint.getAttributesList());

// all attributes must match
info.description(
"missing/unexpected data points attributes for metric '%s'", actual.getName());
containsExactly(dataPointAttributes, attributes);
maps.assertContainsAllEntriesOf(info, dataPointAttributes, attributesMap);
}
});
public final MetricAssert hasDataPointsWithOneAttribute(AttributeMatcher expectedAttribute) {
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

[for reviewer] I left this method for convenience, because there are lots of assertions with just one attribute, but I can remove it if it makes matching logic harder to understand.

return hasDataPointsWithAttributes(attributeGroup(expectedAttribute));
}

/**
* Verifies that all data points have their attributes match one of the attributes set and that
* all provided attributes sets matched at least once.
* Verifies that every data point attributes is matched exactly by one of the matcher groups
* provided. Also, each matcher group must match at least one data point attributes set. Data
* point attributes are matched by matcher group if each attribute is matched by one matcher and
* each matcher matches one attribute. In other words: number of attributes is the same as number
* of matchers and there is 1:1 matching between them.
*
* @param attributeSets sets of attributes as maps
* @param matcherGroups array of attribute matcher groups
* @return this
*/
@SafeVarargs
@CanIgnoreReturnValue
@SuppressWarnings("varargs") // required to avoid warning
public final MetricAssert hasDataPointsAttributes(Map<String, String>... attributeSets) {
public final MetricAssert hasDataPointsWithAttributes(AttributeMatcherGroup... matcherGroups) {
return checkDataPoints(
dataPoints -> {
dataPointsCommonCheck(dataPoints);

boolean[] matchedSets = new boolean[attributeSets.length];
boolean[] matchedSets = new boolean[matcherGroups.length];

// validate each datapoint attributes match exactly one of the provided attributes set
// validate each datapoint attributes match exactly one of the provided attributes sets
for (NumberDataPoint dataPoint : dataPoints) {
Map<String, String> map = toMap(dataPoint.getAttributesList());

Map<String, String> dataPointAttributes =
dataPoint.getAttributesList().stream()
.collect(
Collectors.toMap(KeyValue::getKey, kv -> kv.getValue().getStringValue()));
int matchCount = 0;
for (int i = 0; i < attributeSets.length; i++) {
if (mapEquals(map, attributeSets[i])) {
for (int i = 0; i < matcherGroups.length; i++) {
if (matcherGroups[i].matches(dataPointAttributes)) {
matchedSets[i] = true;
matchCount++;
}
}

info.description(
"data point attributes '%s' for metric '%s' must match exactly one of the attribute sets '%s'",
map, actual.getName(), Arrays.asList(attributeSets));
dataPointAttributes, actual.getName(), Arrays.asList(matcherGroups));
integers.assertEqual(info, matchCount, 1);
}

// check that all attribute sets matched at least once
for (int i = 0; i < matchedSets.length; i++) {
info.description(
"no data point matched attribute set '%s' for metric '%s'",
attributeSets[i], actual.getName());
matcherGroups[i], actual.getName());
objects.assertEqual(info, matchedSets[i], true);
}
});
}

/**
* Map equality utility
*
* @param m1 first map
* @param m2 second map
* @return true if the maps have exactly the same keys and values
*/
private static boolean mapEquals(Map<String, String> m1, Map<String, String> m2) {
if (m1.size() != m2.size()) {
return false;
}
return m1.entrySet().stream().allMatch(e -> e.getValue().equals(m2.get(e.getKey())));
}

@SafeVarargs
@SuppressWarnings("varargs") // required to avoid warning
private final void containsExactly(
Map<String, String> map, Map.Entry<String, String>... entries) {
maps.assertContainsExactly(info, map, entries);
}

private static Map<String, String> toMap(List<KeyValue> list) {
return list.stream()
.collect(Collectors.toMap(KeyValue::getKey, kv -> kv.getValue().getStringValue()));
}
}
Original file line number Diff line number Diff line change
@@ -5,7 +5,8 @@

package io.opentelemetry.contrib.jmxscraper.target_systems;

import static org.assertj.core.api.Assertions.entry;
import static io.opentelemetry.contrib.jmxscraper.assertions.DataPointAttributes.attribute;
import static io.opentelemetry.contrib.jmxscraper.assertions.DataPointAttributes.attributeGroup;

import io.opentelemetry.contrib.jmxscraper.JmxScraperContainer;
import java.nio.file.Path;
@@ -46,37 +47,40 @@ protected MetricsVerifier createMetricsVerifier() {
.hasDescription("The number of consumers currently reading from the broker.")
.hasUnit("{consumer}")
.isUpDownCounter()
.hasDataPointsAttributes(
entry("destination", "ActiveMQ.Advisory.MasterBroker"),
entry("broker", "localhost")))
.hasDataPointsWithAttributes(
attributeGroup(
attribute("destination", "ActiveMQ.Advisory.MasterBroker"),
attribute("broker", "localhost"))))
.add(
"activemq.producer.count",
metric ->
metric
.hasDescription("The number of producers currently attached to the broker.")
.hasUnit("{producer}")
.isUpDownCounter()
.hasDataPointsAttributes(
entry("destination", "ActiveMQ.Advisory.MasterBroker"),
entry("broker", "localhost")))
.hasDataPointsWithAttributes(
attributeGroup(
attribute("destination", "ActiveMQ.Advisory.MasterBroker"),
attribute("broker", "localhost"))))
.add(
"activemq.connection.count",
metric ->
metric
.hasDescription("The total number of current connections.")
.hasUnit("{connection}")
.isUpDownCounter()
.hasDataPointsAttributes(entry("broker", "localhost")))
.hasDataPointsWithOneAttribute(attribute("broker", "localhost")))
.add(
"activemq.memory.usage",
metric ->
metric
.hasDescription("The percentage of configured memory used.")
.hasUnit("%")
.isGauge()
.hasDataPointsAttributes(
entry("destination", "ActiveMQ.Advisory.MasterBroker"),
entry("broker", "localhost")))
.hasDataPointsWithAttributes(
attributeGroup(
attribute("destination", "ActiveMQ.Advisory.MasterBroker"),
attribute("broker", "localhost"))))
.add(
"activemq.disk.store_usage",
metric ->
@@ -85,7 +89,7 @@ protected MetricsVerifier createMetricsVerifier() {
"The percentage of configured disk used for persistent messages.")
.hasUnit("%")
.isGauge()
.hasDataPointsAttributes(entry("broker", "localhost")))
.hasDataPointsWithOneAttribute(attribute("broker", "localhost")))
.add(
"activemq.disk.temp_usage",
metric ->
@@ -94,17 +98,18 @@ protected MetricsVerifier createMetricsVerifier() {
"The percentage of configured disk used for non-persistent messages.")
.hasUnit("%")
.isGauge()
.hasDataPointsAttributes(entry("broker", "localhost")))
.hasDataPointsWithOneAttribute(attribute("broker", "localhost")))
.add(
"activemq.message.current",
metric ->
metric
.hasDescription("The current number of messages waiting to be consumed.")
.hasUnit("{message}")
.isUpDownCounter()
.hasDataPointsAttributes(
entry("destination", "ActiveMQ.Advisory.MasterBroker"),
entry("broker", "localhost")))
.hasDataPointsWithAttributes(
attributeGroup(
attribute("destination", "ActiveMQ.Advisory.MasterBroker"),
attribute("broker", "localhost"))))
.add(
"activemq.message.expired",
metric ->
@@ -113,38 +118,42 @@ protected MetricsVerifier createMetricsVerifier() {
"The total number of messages not delivered because they expired.")
.hasUnit("{message}")
.isCounter()
.hasDataPointsAttributes(
entry("destination", "ActiveMQ.Advisory.MasterBroker"),
entry("broker", "localhost")))
.hasDataPointsWithAttributes(
attributeGroup(
attribute("destination", "ActiveMQ.Advisory.MasterBroker"),
attribute("broker", "localhost"))))
.add(
"activemq.message.enqueued",
metric ->
metric
.hasDescription("The total number of messages received by the broker.")
.hasUnit("{message}")
.isCounter()
.hasDataPointsAttributes(
entry("destination", "ActiveMQ.Advisory.MasterBroker"),
entry("broker", "localhost")))
.hasDataPointsWithAttributes(
attributeGroup(
attribute("destination", "ActiveMQ.Advisory.MasterBroker"),
attribute("broker", "localhost"))))
.add(
"activemq.message.dequeued",
metric ->
metric
.hasDescription("The total number of messages delivered to consumers.")
.hasUnit("{message}")
.isCounter()
.hasDataPointsAttributes(
entry("destination", "ActiveMQ.Advisory.MasterBroker"),
entry("broker", "localhost")))
.hasDataPointsWithAttributes(
attributeGroup(
attribute("destination", "ActiveMQ.Advisory.MasterBroker"),
attribute("broker", "localhost"))))
.add(
"activemq.message.wait_time.avg",
metric ->
metric
.hasDescription("The average time a message was held on a destination.")
.hasUnit("ms")
.isGauge()
.hasDataPointsAttributes(
entry("destination", "ActiveMQ.Advisory.MasterBroker"),
entry("broker", "localhost")));
.hasDataPointsWithAttributes(
attributeGroup(
attribute("destination", "ActiveMQ.Advisory.MasterBroker"),
attribute("broker", "localhost"))));
}
}
Original file line number Diff line number Diff line change
@@ -5,11 +5,13 @@

package io.opentelemetry.contrib.jmxscraper.target_systems;

import static io.opentelemetry.contrib.jmxscraper.assertions.DataPointAttributes.attribute;
import static io.opentelemetry.contrib.jmxscraper.assertions.DataPointAttributes.attributeGroup;

import io.opentelemetry.contrib.jmxscraper.JmxScraperContainer;
import io.opentelemetry.contrib.jmxscraper.assertions.AttributeMatcherGroup;
import java.nio.file.Path;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.containers.wait.strategy.Wait;

@@ -158,18 +160,18 @@ protected MetricsVerifier createMetricsVerifier() {
.hasDescription("Number of requests by operation")
.hasUnit("1")
.isCounter()
.hasDataPointsAttributes(
requestCountAttributes("RangeSlice"),
requestCountAttributes("Read"),
requestCountAttributes("Write")))
.hasDataPointsWithAttributes(
attributeGroup(attribute("operation", "RangeSlice")),
attributeGroup(attribute("operation", "Read")),
attributeGroup(attribute("operation", "Write"))))
.add(
"cassandra.client.request.error.count",
metric ->
metric
.hasDescription("Number of request errors by operation")
.hasUnit("1")
.isCounter()
.hasDataPointsAttributes(
.hasDataPointsWithAttributes(
errorCountAttributes("RangeSlice", "Timeout"),
errorCountAttributes("RangeSlice", "Failure"),
errorCountAttributes("RangeSlice", "Unavailable"),
@@ -181,16 +183,7 @@ protected MetricsVerifier createMetricsVerifier() {
errorCountAttributes("Write", "Unavailable")));
}

private static Map<String, String> errorCountAttributes(String operation, String status) {
Map<String, String> map = new HashMap<>();
map.put("operation", operation);
map.put("status", status);
return map;
}

private static Map<String, String> requestCountAttributes(String operation) {
Map<String, String> map = new HashMap<>();
map.put("operation", operation);
return map;
private static AttributeMatcherGroup errorCountAttributes(String operation, String status) {
return attributeGroup(attribute("operation", operation), attribute("status", status));
}
}

Large diffs are not rendered by default.

Original file line number Diff line number Diff line change
@@ -5,10 +5,9 @@

package io.opentelemetry.contrib.jmxscraper.target_systems;

import static io.opentelemetry.contrib.jmxscraper.target_systems.MetricAssertions.assertGauge;
import static io.opentelemetry.contrib.jmxscraper.target_systems.MetricAssertions.assertGaugeWithAttributes;
import static io.opentelemetry.contrib.jmxscraper.target_systems.MetricAssertions.assertSumWithAttributes;
import static io.opentelemetry.contrib.jmxscraper.target_systems.MetricAssertions.assertSumWithAttributesMultiplePoints;
import static io.opentelemetry.contrib.jmxscraper.assertions.DataPointAttributes.attribute;
import static io.opentelemetry.contrib.jmxscraper.assertions.DataPointAttributes.attributeGroup;
import static io.opentelemetry.contrib.jmxscraper.assertions.DataPointAttributes.attributeWithAnyValue;

import io.opentelemetry.contrib.jmxscraper.JmxScraperContainer;
import java.nio.file.Path;
@@ -55,51 +54,60 @@ protected JmxScraperContainer customizeScraperContainer(
}

@Override
protected void verifyMetrics() {
waitAndAssertMetrics(
metric ->
assertSumWithAttributes(
metric,
"jetty.session.count",
"The number of sessions established in total.",
"{session}",
attrs -> attrs.containsKey("resource")),
metric ->
assertSumWithAttributes(
metric,
"jetty.session.time.total",
"The total time sessions have been active.",
"s",
attrs -> attrs.containsKey("resource")),
metric ->
assertGaugeWithAttributes(
metric,
"jetty.session.time.max",
"The maximum amount of time a session has been active.",
"s",
attrs -> attrs.containsKey("resource")),
metric ->
assertSumWithAttributesMultiplePoints(
metric,
"jetty.select.count",
"The number of select calls.",
"{operation}",
/* isMonotonic= */ true,
// minor divergence from jetty.groovy with extra metrics attributes
attrs -> attrs.containsKey("context").containsKey("id")),
metric ->
assertGaugeWithAttributes(
metric,
"jetty.thread.count",
"The current number of threads.",
"{thread}",
attrs -> attrs.containsEntry("state", "busy"),
attrs -> attrs.containsEntry("state", "idle")),
metric ->
assertGauge(
metric,
"jetty.thread.queue.count",
"The current number of threads in the queue.",
"{thread}"));
protected MetricsVerifier createMetricsVerifier() {
return MetricsVerifier.create()
.add(
"jetty.session.count",
metric ->
metric
.isCounter()
.hasDescription("The number of sessions established in total.")
.hasUnit("{session}")
.hasDataPointsWithOneAttribute(attributeWithAnyValue("resource")))
.add(
"jetty.session.time.total",
metric ->
metric
.isCounter()
.hasDescription("The total time sessions have been active.")
.hasUnit("s")
.hasDataPointsWithOneAttribute(attributeWithAnyValue("resource")))
.add(
"jetty.session.time.max",
metric ->
metric
.isGauge()
.hasDescription("The maximum amount of time a session has been active.")
.hasUnit("s")
.hasDataPointsWithOneAttribute(attributeWithAnyValue("resource")))
.add(
"jetty.select.count",
metric ->
metric
.isCounter()
.hasDescription("The number of select calls.")
.hasUnit("{operation}")
.hasDataPointsWithAttributes(
attributeGroup(
attributeWithAnyValue("context"), attributeWithAnyValue("id"))))
.add(
"jetty.thread.count",
metric ->
metric
.isGauge()
.hasDescription("The current number of threads.")
.hasUnit("{thread}")
.hasDataPointsWithAttributes(
attributeGroup(attribute("state", "busy")),
attributeGroup(attribute("state", "idle"))))
.add(
"jetty.thread.queue.count",
metric ->
metric
.isGauge()
.hasDescription("The current number of threads in the queue.")
.hasUnit("{thread}")
.hasDataPointsWithoutAttributes() // Got rid of id (see jetty.yaml)
);
}
}