From 88ead6497185e3c8f496e1058f6db73fad27ef6f Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Tue, 30 Sep 2025 09:23:44 +0200 Subject: [PATCH 01/19] move activemq to library --- instrumentation/jmx-metrics/README.md | 2 +- .../javaagent/jmx/JmxMetricInsightInstallerTest.java | 2 +- .../jmx-metrics/{javaagent => library}/activemq.md | 0 .../src/main/resources/jmx/rules/activemq.yaml | 0 .../opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java | 4 ++++ 5 files changed, 6 insertions(+), 2 deletions(-) rename instrumentation/jmx-metrics/{javaagent => library}/activemq.md (100%) rename instrumentation/jmx-metrics/{javaagent => library}/src/main/resources/jmx/rules/activemq.yaml (100%) create mode 100644 instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java diff --git a/instrumentation/jmx-metrics/README.md b/instrumentation/jmx-metrics/README.md index 0ac449a32f7a..b429ca5ea03a 100644 --- a/instrumentation/jmx-metrics/README.md +++ b/instrumentation/jmx-metrics/README.md @@ -25,7 +25,7 @@ $ java -javaagent:path/to/opentelemetry-javaagent.jar \ No targets are enabled by default. The supported target environments are listed below. -- [activemq](javaagent/activemq.md) +- [activemq](library/activemq.md) - [camel](javaagent/camel.md) - [jetty](library/jetty.md) - [kafka-broker](javaagent/kafka-broker.md) diff --git a/instrumentation/jmx-metrics/javaagent/src/test/java/io/opentelemetry/instrumentation/javaagent/jmx/JmxMetricInsightInstallerTest.java b/instrumentation/jmx-metrics/javaagent/src/test/java/io/opentelemetry/instrumentation/javaagent/jmx/JmxMetricInsightInstallerTest.java index 2f486ade2e54..2f90a285b302 100644 --- a/instrumentation/jmx-metrics/javaagent/src/test/java/io/opentelemetry/instrumentation/javaagent/jmx/JmxMetricInsightInstallerTest.java +++ b/instrumentation/jmx-metrics/javaagent/src/test/java/io/opentelemetry/instrumentation/javaagent/jmx/JmxMetricInsightInstallerTest.java @@ -31,7 +31,7 @@ class JmxMetricInsightInstallerTest { private static final String PATH_TO_ALL_EXISTING_RULES = "src/main/resources/jmx/rules"; private static final Set FILES_TO_BE_TESTED = - new HashSet<>(Arrays.asList("activemq.yaml", "camel.yaml", "kafka-broker.yaml")); + new HashSet<>(Arrays.asList("camel.yaml", "kafka-broker.yaml")); @Test void testToVerifyExistingRulesAreValid() throws Exception { diff --git a/instrumentation/jmx-metrics/javaagent/activemq.md b/instrumentation/jmx-metrics/library/activemq.md similarity index 100% rename from instrumentation/jmx-metrics/javaagent/activemq.md rename to instrumentation/jmx-metrics/library/activemq.md diff --git a/instrumentation/jmx-metrics/javaagent/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml similarity index 100% rename from instrumentation/jmx-metrics/javaagent/src/main/resources/jmx/rules/activemq.yaml rename to instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java new file mode 100644 index 000000000000..3c9b198c4d0a --- /dev/null +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -0,0 +1,4 @@ +package io.opentelemetry.instrumentation.jmx.rules; + +public class ActiveMqTest { +} From 684be1b98c8f8b0510c53a31bb87fe224b984eaa Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Tue, 30 Sep 2025 09:37:07 +0200 Subject: [PATCH 02/19] start basic activemq instance --- .../jmx/rules/ActiveMqTest.java | 41 ++++++++++++++++++- 1 file changed, 40 insertions(+), 1 deletion(-) diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index 3c9b198c4d0a..3887e5436c73 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -1,4 +1,43 @@ package io.opentelemetry.instrumentation.jmx.rules; -public class ActiveMqTest { +import org.junit.jupiter.api.Test; +import org.testcontainers.containers.GenericContainer; +import org.testcontainers.containers.wait.strategy.Wait; +import org.testcontainers.images.builder.ImageFromDockerfile; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class ActiveMqTest extends TargetSystemTest{ + + + private static final int ACTIVEMQ_PORT = 61616; + + // TODO: test both 'classic' and 'artemis' variants + + @Test + void activemqTest(){ + List yamlFiles = Collections.singletonList("activemq.yaml"); + + yamlFiles.forEach(this::validateYamlSyntax); + + List jvmArgs = new ArrayList<>(); + jvmArgs.add(javaAgentJvmArgument()); + jvmArgs.addAll(javaPropertiesToJvmArgs(otelConfigProperties(yamlFiles))); + + GenericContainer target = new GenericContainer<>( + new ImageFromDockerfile() + .withDockerfileFromBuilder( + builder -> builder.from("apache/activemq-classic:5.18.6").build())) + .withEnv("JAVA_TOOL_OPTIONS", String.join(" ", jvmArgs)) + .withStartupTimeout(Duration.ofMinutes(2)) + .withExposedPorts(ACTIVEMQ_PORT) + .waitingFor(Wait.forListeningPorts(ACTIVEMQ_PORT)); + + copyAgentToTarget(target); + copyYamlFilesToTarget(target, yamlFiles); + + startTarget(target); + } } From 606f7b26a5d6bd408f14230441157df0a272400a Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 14:15:41 +0200 Subject: [PATCH 03/19] messaging + consumer/producer metrics --- .../main/resources/jmx/rules/activemq.yaml | 34 ++++++++++++------- 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index c7d669d55282..18f75b655776 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -4,16 +4,23 @@ rules: - org.apache.activemq:type=Broker,brokerName=*,destinationType=Queue,destinationName=* - org.apache.activemq:type=Broker,brokerName=*,destinationType=Topic,destinationName=* metricAttribute: - destination: param(destinationName) - broker: param(brokerName) + messaging.destination.name: param(destinationName) + messaging.system: const(activemq) + # 'topic' or 'queue' + activemq.destination.type: lowercase(param(destinationType)) + activemq.broker.name: param(brokerName) prefix: activemq. mapping: + # activemq.producer.count ProducerCount: - unit: "{producers}" + metric: producer.count + unit: "{producer}" type: updowncounter desc: The number of producers attached to this destination + # activemq.consumer.count ConsumerCount: - unit: "{consumers}" + metric: consumer.count + unit: "{consumer}" type: updowncounter desc: The number of consumers subscribed to this destination MemoryPercentUsage: @@ -22,23 +29,26 @@ rules: type: gauge desc: The percentage of configured memory used QueueSize: - metric: message.QueueSize - unit: "{messages}" + metric: message.queue.size + unit: "{message}" type: updowncounter desc: The current number of messages waiting to be consumed + # activemq.message.expired ExpiredCount: - metric: message.ExpiredCount - unit: "{messages}" + metric: message.expired + unit: "{message}" type: counter desc: The number of messages not delivered because they expired + # activemq.message.enqueued EnqueueCount: - metric: message.EnqueueCount - unit: "{messages}" + metric: message.enqueued + unit: "{message}" type: counter desc: The number of messages sent to this destination + # activemq.message.dequeued DequeueCount: - metric: message.DequeueCount - unit: "{messages}" + metric: message.dequeued + unit: "{message}" type: counter desc: The number of messages acknowledged and removed from this destination AverageEnqueueTime: From a7939d54e18818ffdf166b5fd8b562b396c69ef0 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 14:17:46 +0200 Subject: [PATCH 04/19] start adding tests --- .../jmx/rules/ActiveMqTest.java | 61 ++++++++++++++++--- 1 file changed, 54 insertions(+), 7 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index 3887e5436c73..a8fca973bad8 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -1,23 +1,27 @@ package io.opentelemetry.instrumentation.jmx.rules; -import org.junit.jupiter.api.Test; -import org.testcontainers.containers.GenericContainer; -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.images.builder.ImageFromDockerfile; +import static io.opentelemetry.instrumentation.jmx.rules.assertions.DataPointAttributes.attribute; +import static io.opentelemetry.instrumentation.jmx.rules.assertions.DataPointAttributes.attributeGroup; + +import io.opentelemetry.instrumentation.jmx.rules.assertions.AttributeMatcher; +import io.opentelemetry.instrumentation.jmx.rules.assertions.AttributeMatcherGroup; import java.time.Duration; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import org.junit.jupiter.api.Test; +import org.testcontainers.containers.GenericContainer; +import org.testcontainers.containers.wait.strategy.Wait; +import org.testcontainers.images.builder.ImageFromDockerfile; -public class ActiveMqTest extends TargetSystemTest{ - +public class ActiveMqTest extends TargetSystemTest { private static final int ACTIVEMQ_PORT = 61616; // TODO: test both 'classic' and 'artemis' variants @Test - void activemqTest(){ + void activemqTest() { List yamlFiles = Collections.singletonList("activemq.yaml"); yamlFiles.forEach(this::validateYamlSyntax); @@ -39,5 +43,48 @@ void activemqTest(){ copyYamlFilesToTarget(target, yamlFiles); startTarget(target); + + verifyMetrics(createMetricsVerifier()); + } + + private static MetricsVerifier createMetricsVerifier() { + + AttributeMatcher messagingSystem = attribute("messaging.system", "activemq"); + // known attributes from the single topic available by default + AttributeMatcher destinationName = attribute("messaging.destination.name", + "ActiveMQ.Advisory.MasterBroker"); + AttributeMatcher topic = attribute("activemq.destination.type", "topic"); + AttributeMatcher broker = attribute("activemq.broker.name", "localhost"); + + AttributeMatcherGroup topicAttributes = + attributeGroup(messagingSystem, destinationName, topic, broker); + + return MetricsVerifier.create() + // consumers and producers + .add("activemq.producer.count", metric -> metric.isUpDownCounter() + .hasUnit("{producer}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of producers attached to this destination")) + .add("activemq.consumer.count", metric -> metric.isUpDownCounter() + .hasUnit("{consumer}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of consumers subscribed to this destination")) + // message consumption and in-flight + .add("activemq.message.queue.size", metric -> metric.isUpDownCounter() + .hasUnit("{message}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The current number of messages waiting to be consumed")) + .add("activemq.message.expired",metric -> metric.isCounter() + .hasUnit("{message}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of messages not delivered because they expired")) + .add("activemq.message.enqueued",metric -> metric.isCounter() + .hasUnit("{message}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of messages sent to this destination")) + .add("activemq.message.dequeued",metric -> metric.isCounter() + .hasUnit("{message}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of messages acknowledged and removed from this destination")); } } From 93783547467ae3797dfc6c4aa3bd15c2e682a3e0 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 16:17:45 +0200 Subject: [PATCH 05/19] wip --- .../main/resources/jmx/rules/activemq.yaml | 73 +++++++++++++------ .../jmx/rules/ActiveMqTest.java | 37 +++++++++- 2 files changed, 85 insertions(+), 25 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index 18f75b655776..1404c60b0463 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -1,5 +1,7 @@ --- rules: + + # Topic and Queues level metrics - beans: - org.apache.activemq:type=Broker,brokerName=*,destinationType=Queue,destinationName=* - org.apache.activemq:type=Broker,brokerName=*,destinationType=Topic,destinationName=* @@ -23,11 +25,31 @@ rules: unit: "{consumer}" type: updowncounter desc: The number of consumers subscribed to this destination - MemoryPercentUsage: - metric: memory.MemoryPercentUsage - unit: "%" + # activemq.memory.usage + MemoryUsageByteCount: + metric: memory.usage + unit: By + type: updowncounter + desc: The amount of used memory + # activemq.memory.limit + MemoryLimit: + metric: memory.limit + unit: By + type: updowncounter + desc: The amount of configured memory limit + # activemq.temp.utilization + TempUsagePercentUsage: + metric: temp.utilization + unit: "1" type: gauge - desc: The percentage of configured memory used + desc: The percentage of non-persistent storage used + # activemq.temp.limit + TempUsageLimit: + metric: temp.limit + unit: By + type: updowncounter + desc: The amount of configured non-persistent storage limit + # activemq.message.queue.size QueueSize: metric: message.queue.size unit: "{message}" @@ -51,27 +73,36 @@ rules: unit: "{message}" type: counter desc: The number of messages acknowledged and removed from this destination - AverageEnqueueTime: - metric: message.AverageEnqueueTime - unit: ms - type: gauge - desc: The average time a message was held on this destination + + # Broker-level metrics - bean: org.apache.activemq:type=Broker,brokerName=* metricAttribute: - broker: param(brokerName) + messaging.system: const(activemq) + activemq.broker.name: param(brokerName) prefix: activemq. - unit: "%" - type: gauge mapping: + # activemq.connection.count CurrentConnectionsCount: - metric: connections.CurrentConnectionsCount + metric: connection.count + type: updowncounter + unit: "{connection}" + desc: The number of active connections + # activemq.broker.memory.limit + MemoryPercentLimit: + metric: broker.temp.limit + type: updowncounter + unit: By + desc: The amount of configured broker non-persistent storage limit + # activemq.broker.store.limit + StorePercentLimit: + metric: broker.store.limit + type: updowncounter + unit: By + desc: The amount of configured broker persistent storage limit + # activemq.broker.temp.limit + TempPercentLimit: + metric: broker.temp.limit type: updowncounter - unit: "{connections}" - desc: The total number of current connections - StorePercentUsage: - metric: disc.StorePercentUsage - desc: The percentage of configured disk used for persistent messages - TempPercentUsage: - metric: disc.TempPercentUsage - desc: The percentage of configured disk used for non-persistent messages + unit: By + desc: The amount of configured broker non-persistent storage limit diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index a8fca973bad8..67c07aff94f9 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -59,6 +59,9 @@ private static MetricsVerifier createMetricsVerifier() { AttributeMatcherGroup topicAttributes = attributeGroup(messagingSystem, destinationName, topic, broker); + AttributeMatcherGroup brokerAttributes = + attributeGroup(messagingSystem, broker); + return MetricsVerifier.create() // consumers and producers .add("activemq.producer.count", metric -> metric.isUpDownCounter() @@ -74,17 +77,43 @@ private static MetricsVerifier createMetricsVerifier() { .hasUnit("{message}") .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The current number of messages waiting to be consumed")) - .add("activemq.message.expired",metric -> metric.isCounter() + .add("activemq.message.expired", metric -> metric.isCounter() .hasUnit("{message}") .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The number of messages not delivered because they expired")) - .add("activemq.message.enqueued",metric -> metric.isCounter() + .add("activemq.message.enqueued", metric -> metric.isCounter() .hasUnit("{message}") .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The number of messages sent to this destination")) - .add("activemq.message.dequeued",metric -> metric.isCounter() + .add("activemq.message.dequeued", metric -> metric.isCounter() .hasUnit("{message}") .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The number of messages acknowledged and removed from this destination")); + .hasDescription( + "The number of messages acknowledged and removed from this destination")) + // destination memory/temp usage and limits + .add("activemq.memory.usage", metric -> metric.isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The amount of used memory")) + .add("activemq.memory.limit", metric -> metric.isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The amount of configured memory limit")) + .add("activemq.temp.utilization", metric -> metric.isGauge() + .hasUnit("1") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The percentage of non-persistent storage used")) + .add("activemq.temp.limit", metric -> metric.isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The amount of configured non-persistent storage limit")) + // broker metrics + .add("activemq.connection.count", metric ->metric.isUpDownCounter() + .hasUnit("{connection}") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The number of active connections") + ) + ; + // TODO broker memory/temp/storage usage and limits } } From 2bbd993ba53583a2af15c112f49fceac0e9b251d Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 16:39:03 +0200 Subject: [PATCH 06/19] broker metrics to top level, destination lower --- .../main/resources/jmx/rules/activemq.yaml | 52 +++++++++++++------ 1 file changed, 35 insertions(+), 17 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index 1404c60b0463..8d692a97497f 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -25,27 +25,27 @@ rules: unit: "{consumer}" type: updowncounter desc: The number of consumers subscribed to this destination - # activemq.memory.usage + # activemq.memory.destination.usage MemoryUsageByteCount: - metric: memory.usage + metric: memory.destination.usage unit: By type: updowncounter desc: The amount of used memory - # activemq.memory.limit + # activemq.memory.destination.limit MemoryLimit: - metric: memory.limit + metric: memory.destination.limit unit: By type: updowncounter desc: The amount of configured memory limit - # activemq.temp.utilization + # activemq.temp.destination.utilization TempUsagePercentUsage: - metric: temp.utilization + metric: temp.destination.utilization unit: "1" type: gauge desc: The percentage of non-persistent storage used - # activemq.temp.limit + # activemq.temp.destination.limit TempUsageLimit: - metric: temp.limit + metric: temp.destination.limit unit: By type: updowncounter desc: The amount of configured non-persistent storage limit @@ -88,21 +88,39 @@ rules: type: updowncounter unit: "{connection}" desc: The number of active connections - # activemq.broker.memory.limit - MemoryPercentLimit: - metric: broker.temp.limit + # activemq.memory.utilization + MemoryPercentUsage: + metric: memory.utilization + type: gauge + unit: "1" + desc: The percentage of broker memory used + # activemq.memory.limit + MemoryLimit: + metric: memory.limit type: updowncounter unit: By - desc: The amount of configured broker non-persistent storage limit - # activemq.broker.store.limit + desc: The amount of configured broker memory limit + # activemq.store.utilization + StorePercentUsage: + metric: store.utilization + type: gauge + unit: "1" + desc: The percentage of broker persistent storage used + # activemq.store.limit StorePercentLimit: - metric: broker.store.limit + metric: store.limit type: updowncounter unit: By desc: The amount of configured broker persistent storage limit - # activemq.broker.temp.limit - TempPercentLimit: - metric: broker.temp.limit + # activemq.temp.utilization + TempPercentUsage: + metric: temp.utilization + type: gauge + unit: "1" + desc: The percentage of broker non-persistent storage used + # activemq.temp.limit + TempLimit: + metric: temp.limit type: updowncounter unit: By desc: The amount of configured broker non-persistent storage limit From 974fce3ec3cf8966f1e186d2267de0fedaa5fa37 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 18:46:32 +0200 Subject: [PATCH 07/19] fix tests and move some to 'destination' --- .../main/resources/jmx/rules/activemq.yaml | 2 +- .../jmx/rules/ActiveMqTest.java | 35 +++++++++++++++---- 2 files changed, 30 insertions(+), 7 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index 8d692a97497f..606205e99fce 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -107,7 +107,7 @@ rules: unit: "1" desc: The percentage of broker persistent storage used # activemq.store.limit - StorePercentLimit: + StoreLimit: metric: store.limit type: updowncounter unit: By diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index 67c07aff94f9..06883dd3fe55 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -91,19 +91,19 @@ private static MetricsVerifier createMetricsVerifier() { .hasDescription( "The number of messages acknowledged and removed from this destination")) // destination memory/temp usage and limits - .add("activemq.memory.usage", metric -> metric.isUpDownCounter() + .add("activemq.memory.destination.usage", metric -> metric.isUpDownCounter() .hasUnit("By") .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The amount of used memory")) - .add("activemq.memory.limit", metric -> metric.isUpDownCounter() + .add("activemq.memory.destination.limit", metric -> metric.isUpDownCounter() .hasUnit("By") .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The amount of configured memory limit")) - .add("activemq.temp.utilization", metric -> metric.isGauge() + .add("activemq.temp.destination.utilization", metric -> metric.isGauge() .hasUnit("1") .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The percentage of non-persistent storage used")) - .add("activemq.temp.limit", metric -> metric.isUpDownCounter() + .add("activemq.temp.destination.limit", metric -> metric.isUpDownCounter() .hasUnit("By") .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The amount of configured non-persistent storage limit")) @@ -111,8 +111,31 @@ private static MetricsVerifier createMetricsVerifier() { .add("activemq.connection.count", metric ->metric.isUpDownCounter() .hasUnit("{connection}") .hasDataPointsWithAttributes(brokerAttributes) - .hasDescription("The number of active connections") - ) + .hasDescription("The number of active connections")) + .add("activemq.memory.utilization", metric -> metric.isGauge() + .hasUnit("1") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The percentage of broker memory used")) + .add("activemq.memory.limit", metric -> metric.isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The amount of configured broker memory limit")) + .add("activemq.store.utilization", metric -> metric.isGauge() + .hasUnit("1") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The percentage of broker persistent storage used")) + .add("activemq.store.limit", metric -> metric.isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The amount of configured broker persistent storage limit")) + .add("activemq.temp.utilization", metric -> metric.isGauge() + .hasUnit("1") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The percentage of broker non-persistent storage used")) + .add("activemq.temp.limit", metric -> metric.isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The amount of configured broker non-persistent storage limit")) ; // TODO broker memory/temp/storage usage and limits } From aa88e69cc8fbe19cf2d0579ea49169eb4dd0a7e7 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 19:30:16 +0200 Subject: [PATCH 08/19] add percentage unit conversion --- .../jmx/engine/UnitConverter.java | 1 + .../jmx/engine/UnitConverterTest.java | 21 ++++++++++++++----- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/main/java/io/opentelemetry/instrumentation/jmx/engine/UnitConverter.java b/instrumentation/jmx-metrics/library/src/main/java/io/opentelemetry/instrumentation/jmx/engine/UnitConverter.java index 8e4fbbf4da3f..0e3d3e8d405e 100644 --- a/instrumentation/jmx-metrics/library/src/main/java/io/opentelemetry/instrumentation/jmx/engine/UnitConverter.java +++ b/instrumentation/jmx-metrics/library/src/main/java/io/opentelemetry/instrumentation/jmx/engine/UnitConverter.java @@ -22,6 +22,7 @@ class UnitConverter { registerConversion("ms", "s", value -> value.doubleValue() / TimeUnit.SECONDS.toMillis(1)); registerConversion("us", "s", value -> value.doubleValue() / TimeUnit.SECONDS.toMicros(1)); registerConversion("ns", "s", value -> value.doubleValue() / TimeUnit.SECONDS.toNanos(1)); + registerConversion("%", "1", value -> value.doubleValue() / 100d); } private final Function convertingFunction; diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/engine/UnitConverterTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/engine/UnitConverterTest.java index 4221059b443e..13f6eec4fbca 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/engine/UnitConverterTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/engine/UnitConverterTest.java @@ -32,15 +32,26 @@ class UnitConverterTest { }) void shouldSupportPredefined_to_s_Conversions( Long originalValue, String originalUnit, Double expectedConvertedValue) { - // Given - String targetUnit = "s"; + testConversion(originalValue, originalUnit, expectedConvertedValue, "s"); + } - // When + @ParameterizedTest + @CsvSource({ + "100,1.0", "99,0.99", "1,0.01", "0,0", + }) + void shouldSupportPredefined_percent_Conversions( + Long originalValue, Double expectedConvertedValue) { + testConversion(originalValue, "%", expectedConvertedValue, "1"); + } + + private static void testConversion( + Long originalValue, String originalUnit, Double expectedConvertedValue, String targetUnit) { UnitConverter converter = UnitConverter.getInstance(originalUnit, targetUnit); + + assertThat(converter).isNotNull(); Number actualValue = converter.convert(originalValue); - // Then - assertEquals(expectedConvertedValue, actualValue); + assertThat(expectedConvertedValue).isEqualTo(actualValue); } @ParameterizedTest From 53e8deec42f44d24def2b3f9ae29674c83dfe6ff Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 19:33:15 +0200 Subject: [PATCH 09/19] add percentage unit conversion --- .../library/src/main/resources/jmx/rules/activemq.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index 606205e99fce..32e253ad2207 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -92,6 +92,7 @@ rules: MemoryPercentUsage: metric: memory.utilization type: gauge + sourceUnit: "%" unit: "1" desc: The percentage of broker memory used # activemq.memory.limit @@ -104,6 +105,7 @@ rules: StorePercentUsage: metric: store.utilization type: gauge + sourceUnit: "%" unit: "1" desc: The percentage of broker persistent storage used # activemq.store.limit @@ -116,6 +118,7 @@ rules: TempPercentUsage: metric: temp.utilization type: gauge + sourceUnit: "%" unit: "1" desc: The percentage of broker non-persistent storage used # activemq.temp.limit From 0ebf5bde0f7f679ceda8237a9bf2369d3ad0dd49 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 19:33:31 +0200 Subject: [PATCH 10/19] reformat tests --- .../jmx/rules/ActiveMqTest.java | 238 ++++++++++++------ 1 file changed, 155 insertions(+), 83 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index 06883dd3fe55..6d05a7bfb996 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.instrumentation.jmx.rules; import static io.opentelemetry.instrumentation.jmx.rules.assertions.DataPointAttributes.attribute; @@ -30,14 +35,15 @@ void activemqTest() { jvmArgs.add(javaAgentJvmArgument()); jvmArgs.addAll(javaPropertiesToJvmArgs(otelConfigProperties(yamlFiles))); - GenericContainer target = new GenericContainer<>( - new ImageFromDockerfile() - .withDockerfileFromBuilder( - builder -> builder.from("apache/activemq-classic:5.18.6").build())) - .withEnv("JAVA_TOOL_OPTIONS", String.join(" ", jvmArgs)) - .withStartupTimeout(Duration.ofMinutes(2)) - .withExposedPorts(ACTIVEMQ_PORT) - .waitingFor(Wait.forListeningPorts(ACTIVEMQ_PORT)); + GenericContainer target = + new GenericContainer<>( + new ImageFromDockerfile() + .withDockerfileFromBuilder( + builder -> builder.from("apache/activemq-classic:5.18.6").build())) + .withEnv("JAVA_TOOL_OPTIONS", String.join(" ", jvmArgs)) + .withStartupTimeout(Duration.ofMinutes(2)) + .withExposedPorts(ACTIVEMQ_PORT) + .waitingFor(Wait.forListeningPorts(ACTIVEMQ_PORT)); copyAgentToTarget(target); copyYamlFilesToTarget(target, yamlFiles); @@ -51,92 +57,158 @@ private static MetricsVerifier createMetricsVerifier() { AttributeMatcher messagingSystem = attribute("messaging.system", "activemq"); // known attributes from the single topic available by default - AttributeMatcher destinationName = attribute("messaging.destination.name", - "ActiveMQ.Advisory.MasterBroker"); + AttributeMatcher destinationName = + attribute("messaging.destination.name", "ActiveMQ.Advisory.MasterBroker"); AttributeMatcher topic = attribute("activemq.destination.type", "topic"); AttributeMatcher broker = attribute("activemq.broker.name", "localhost"); AttributeMatcherGroup topicAttributes = attributeGroup(messagingSystem, destinationName, topic, broker); - AttributeMatcherGroup brokerAttributes = - attributeGroup(messagingSystem, broker); + AttributeMatcherGroup brokerAttributes = attributeGroup(messagingSystem, broker); return MetricsVerifier.create() // consumers and producers - .add("activemq.producer.count", metric -> metric.isUpDownCounter() - .hasUnit("{producer}") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The number of producers attached to this destination")) - .add("activemq.consumer.count", metric -> metric.isUpDownCounter() - .hasUnit("{consumer}") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The number of consumers subscribed to this destination")) + .add( + "activemq.producer.count", + metric -> + metric + .isUpDownCounter() + .hasUnit("{producer}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of producers attached to this destination")) + .add( + "activemq.consumer.count", + metric -> + metric + .isUpDownCounter() + .hasUnit("{consumer}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of consumers subscribed to this destination")) // message consumption and in-flight - .add("activemq.message.queue.size", metric -> metric.isUpDownCounter() - .hasUnit("{message}") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The current number of messages waiting to be consumed")) - .add("activemq.message.expired", metric -> metric.isCounter() - .hasUnit("{message}") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The number of messages not delivered because they expired")) - .add("activemq.message.enqueued", metric -> metric.isCounter() - .hasUnit("{message}") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The number of messages sent to this destination")) - .add("activemq.message.dequeued", metric -> metric.isCounter() - .hasUnit("{message}") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription( - "The number of messages acknowledged and removed from this destination")) + .add( + "activemq.message.queue.size", + metric -> + metric + .isUpDownCounter() + .hasUnit("{message}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The current number of messages waiting to be consumed")) + .add( + "activemq.message.expired", + metric -> + metric + .isCounter() + .hasUnit("{message}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of messages not delivered because they expired")) + .add( + "activemq.message.enqueued", + metric -> + metric + .isCounter() + .hasUnit("{message}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The number of messages sent to this destination")) + .add( + "activemq.message.dequeued", + metric -> + metric + .isCounter() + .hasUnit("{message}") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription( + "The number of messages acknowledged and removed from this destination")) // destination memory/temp usage and limits - .add("activemq.memory.destination.usage", metric -> metric.isUpDownCounter() - .hasUnit("By") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The amount of used memory")) - .add("activemq.memory.destination.limit", metric -> metric.isUpDownCounter() - .hasUnit("By") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The amount of configured memory limit")) - .add("activemq.temp.destination.utilization", metric -> metric.isGauge() - .hasUnit("1") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The percentage of non-persistent storage used")) - .add("activemq.temp.destination.limit", metric -> metric.isUpDownCounter() - .hasUnit("By") - .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The amount of configured non-persistent storage limit")) + .add( + "activemq.memory.destination.usage", + metric -> + metric + .isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The amount of used memory")) + .add( + "activemq.memory.destination.limit", + metric -> + metric + .isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The amount of configured memory limit")) + .add( + "activemq.temp.destination.utilization", + metric -> + metric + .isGauge() + .hasUnit("1") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The percentage of non-persistent storage used")) + .add( + "activemq.temp.destination.limit", + metric -> + metric + .isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription("The amount of configured non-persistent storage limit")) // broker metrics - .add("activemq.connection.count", metric ->metric.isUpDownCounter() - .hasUnit("{connection}") - .hasDataPointsWithAttributes(brokerAttributes) - .hasDescription("The number of active connections")) - .add("activemq.memory.utilization", metric -> metric.isGauge() - .hasUnit("1") - .hasDataPointsWithAttributes(brokerAttributes) - .hasDescription("The percentage of broker memory used")) - .add("activemq.memory.limit", metric -> metric.isUpDownCounter() - .hasUnit("By") - .hasDataPointsWithAttributes(brokerAttributes) - .hasDescription("The amount of configured broker memory limit")) - .add("activemq.store.utilization", metric -> metric.isGauge() - .hasUnit("1") - .hasDataPointsWithAttributes(brokerAttributes) - .hasDescription("The percentage of broker persistent storage used")) - .add("activemq.store.limit", metric -> metric.isUpDownCounter() - .hasUnit("By") - .hasDataPointsWithAttributes(brokerAttributes) - .hasDescription("The amount of configured broker persistent storage limit")) - .add("activemq.temp.utilization", metric -> metric.isGauge() - .hasUnit("1") - .hasDataPointsWithAttributes(brokerAttributes) - .hasDescription("The percentage of broker non-persistent storage used")) - .add("activemq.temp.limit", metric -> metric.isUpDownCounter() - .hasUnit("By") - .hasDataPointsWithAttributes(brokerAttributes) - .hasDescription("The amount of configured broker non-persistent storage limit")) - ; - // TODO broker memory/temp/storage usage and limits + .add( + "activemq.connection.count", + metric -> + metric + .isUpDownCounter() + .hasUnit("{connection}") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The number of active connections")) + .add( + "activemq.memory.utilization", + metric -> + metric + .isGauge() + .hasUnit("1") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The percentage of broker memory used")) + .add( + "activemq.memory.limit", + metric -> + metric + .isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The amount of configured broker memory limit")) + .add( + "activemq.store.utilization", + metric -> + metric + .isGauge() + .hasUnit("1") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The percentage of broker persistent storage used")) + .add( + "activemq.store.limit", + metric -> + metric + .isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The amount of configured broker persistent storage limit")) + .add( + "activemq.temp.utilization", + metric -> + metric + .isGauge() + .hasUnit("1") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription("The percentage of broker non-persistent storage used")) + .add( + "activemq.temp.limit", + metric -> + metric + .isUpDownCounter() + .hasUnit("By") + .hasDataPointsWithAttributes(brokerAttributes) + .hasDescription( + "The amount of configured broker non-persistent storage limit")); } } From c4126bf0f7d91348357d13f1db3d90a101c86c22 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 20:59:23 +0200 Subject: [PATCH 11/19] reformat table --- instrumentation/jmx-metrics/library/activemq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/instrumentation/jmx-metrics/library/activemq.md b/instrumentation/jmx-metrics/library/activemq.md index 49a01985291e..6d433d9a4fb1 100644 --- a/instrumentation/jmx-metrics/library/activemq.md +++ b/instrumentation/jmx-metrics/library/activemq.md @@ -3,7 +3,7 @@ Here is the list of metrics based on MBeans exposed by ActiveMQ. | Metric Name | Type | Attributes | Description | -| -------------------------------------------- | ------------- | ------------------- | --------------------------------------------------------------------- | +|----------------------------------------------|---------------|---------------------|-----------------------------------------------------------------------| | activemq.ProducerCount | UpDownCounter | destination, broker | The number of producers attached to this destination | | activemq.ConsumerCount | UpDownCounter | destination, broker | The number of consumers subscribed to this destination | | activemq.memory.MemoryPercentUsage | Gauge | destination, broker | The percentage of configured memory used | From 9efbb685c323e84f6c61bc777915aa1eacf844d9 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 21:00:14 +0200 Subject: [PATCH 12/19] simplify bean definition --- .../library/src/main/resources/jmx/rules/activemq.yaml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index 32e253ad2207..9c236879c45b 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -2,9 +2,7 @@ rules: # Topic and Queues level metrics - - beans: - - org.apache.activemq:type=Broker,brokerName=*,destinationType=Queue,destinationName=* - - org.apache.activemq:type=Broker,brokerName=*,destinationType=Topic,destinationName=* + - bean: org.apache.activemq:type=Broker,brokerName=*,destinationType=*,destinationName=* metricAttribute: messaging.destination.name: param(destinationName) messaging.system: const(activemq) From 413707f1bdb3febc0ec8211a3b50c3ddcdbed71e Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 21:30:10 +0200 Subject: [PATCH 13/19] use latest classic version --- .../opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index 6d05a7bfb996..61786818b807 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -39,7 +39,7 @@ void activemqTest() { new GenericContainer<>( new ImageFromDockerfile() .withDockerfileFromBuilder( - builder -> builder.from("apache/activemq-classic:5.18.6").build())) + builder -> builder.from("apache/activemq-classic:6.1.7").build())) .withEnv("JAVA_TOOL_OPTIONS", String.join(" ", jvmArgs)) .withStartupTimeout(Duration.ofMinutes(2)) .withExposedPorts(ACTIVEMQ_PORT) From 2f38f922927ac9f590b3c459225f0883ddffc087 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 21:57:06 +0200 Subject: [PATCH 14/19] add avg time spent in queue --- .../src/main/resources/jmx/rules/activemq.yaml | 8 +++++++- .../instrumentation/jmx/rules/ActiveMqTest.java | 11 +++++++++-- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index 9c236879c45b..9085fa8dc84a 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -71,7 +71,13 @@ rules: unit: "{message}" type: counter desc: The number of messages acknowledged and removed from this destination - + # activemq.message.enqueue.average_duration + AverageEnqueueTime: + metric: message.enqueue.average_duration + sourceUnit: ms + unit: s + type: gauge + desc: The average time a message was held on this destination # Broker-level metrics - bean: org.apache.activemq:type=Broker,brokerName=* diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index 61786818b807..d521712677c5 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -23,8 +23,6 @@ public class ActiveMqTest extends TargetSystemTest { private static final int ACTIVEMQ_PORT = 61616; - // TODO: test both 'classic' and 'artemis' variants - @Test void activemqTest() { List yamlFiles = Collections.singletonList("activemq.yaml"); @@ -119,6 +117,15 @@ private static MetricsVerifier createMetricsVerifier() { .hasDataPointsWithAttributes(topicAttributes) .hasDescription( "The number of messages acknowledged and removed from this destination")) + .add( + "activemq.message.enqueue.average_duration", + metric -> + metric + .isGauge() + .hasUnit("s") + .hasDataPointsWithAttributes(topicAttributes) + .hasDescription( + "The average time a message was held on this destination")) // destination memory/temp usage and limits .add( "activemq.memory.destination.usage", From f38757b2ad43b226377b31688c4d819098af6a56 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Wed, 15 Oct 2025 22:27:14 +0200 Subject: [PATCH 15/19] minor wording + document --- .../jmx-metrics/library/activemq.md | 42 +++++++++++++------ .../main/resources/jmx/rules/activemq.yaml | 8 ++-- .../jmx/rules/ActiveMqTest.java | 8 ++-- 3 files changed, 37 insertions(+), 21 deletions(-) diff --git a/instrumentation/jmx-metrics/library/activemq.md b/instrumentation/jmx-metrics/library/activemq.md index 6d433d9a4fb1..cd1cf0197954 100644 --- a/instrumentation/jmx-metrics/library/activemq.md +++ b/instrumentation/jmx-metrics/library/activemq.md @@ -2,16 +2,32 @@ Here is the list of metrics based on MBeans exposed by ActiveMQ. -| Metric Name | Type | Attributes | Description | -|----------------------------------------------|---------------|---------------------|-----------------------------------------------------------------------| -| activemq.ProducerCount | UpDownCounter | destination, broker | The number of producers attached to this destination | -| activemq.ConsumerCount | UpDownCounter | destination, broker | The number of consumers subscribed to this destination | -| activemq.memory.MemoryPercentUsage | Gauge | destination, broker | The percentage of configured memory used | -| activemq.message.QueueSize | UpDownCounter | destination, broker | The current number of messages waiting to be consumed | -| activemq.message.ExpiredCount | Counter | destination, broker | The number of messages not delivered because they expired | -| activemq.message.EnqueueCount | Counter | destination, broker | The number of messages sent to this destination | -| activemq.message.DequeueCount | Counter | destination, broker | The number of messages acknowledged and removed from this destination | -| activemq.message.AverageEnqueueTime | Gauge | destination, broker | The average time a message was held on this destination | -| activemq.connections.CurrentConnectionsCount | UpDownCounter | | The total number of current connections | -| activemq.disc.StorePercentUsage | Gauge | | The percentage of configured disk used for persistent messages | -| activemq.disc.TempPercentUsage | Gauge | | The percentage of configured disk used for non-persistent messages | +For now, only ActiveMQ classic is supported. + +| Metric Name | Type | Unit | Attributes | Description | +|-------------------------------------------|---------------|--------------|-----------------------------------------------------------------------------------------------|-----------------------------------------------------------------------| +| activemq.producer.count | UpDownCounter | {producer} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of producers attached to this destination | +| activemq.consumer.count | UpDownCounter | {consumer} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of consumers subscribed to this destination | +| activemq.memory.destination.usage | UpDownCounter | By | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of used memory by this destination | +| activemq.memory.destination.limit | UpDownCounter | By | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured memory limit for this destination | +| activemq.temp.destination.utilization | gauge | 1 | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The percentage of non-persistent storage used by this destination | +| activemq.temp.destination.limit | UpDownCounter | By | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured non-persistent storage limit | +| activemq.message.queue.size | UpDownCounter | {message} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The current number of messages waiting to be consumed | +| activemq.message.expired | Counter | {message} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages not delivered because they expired | +| activemq.message.enqueued | Counter | {message} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages sent to this destination | +| activemq.message.dequeued | Counter | {message} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages acknowledged and removed from this destination | +| activemq.message.enqueue.average_duration | Gauge | s | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The average time a message was held on this destination | +| activemq.connection.count | UpDownCounter | {connection} | messaging.system, activemq.broker.name | The number of active connections | +| activemq.memory.utilization | Gauge | 1 | messaging.system, activemq.broker.name | The percentage of broker memory used | +| activemq.memory.limit | UpDownCounter | By | messaging.system, activemq.broker.name | The amount of configured broker memory limit | +| activemq.store.utilization | Gauge | 1 | messaging.system, activemq.broker.name | The percentage of broker persistent storage used | +| activemq.store.limit | UpDownCounter | By | messaging.system, activemq.broker.name | The amount of configured broker persistent storage limit | +| activemq.temp.utilization | Gauge | 1 | messaging.system, activemq.broker.name | The percentage of broker non-persistent storage used | +| activemq.temp.limit | UpDownCounter | By | messaging.system, activemq.broker.name | The amount of configured broker non-persistent storage limit | + +## Attributes + +- `messaging.system` is always set to `activemq` ([semconv](https://opentelemetry.io/docs/specs/semconv/registry/attributes/messaging/#messaging-system)) +- `messaging.destination.name` contains the destination.name ([semconv](https://opentelemetry.io/docs/specs/semconv/registry/attributes/messaging/#messaging-destination-name)) +- `activemq.broker.name` contains the name of the broker +- `activemq.destination.type` is set to `queue` for queues (point-to-point), `topic` for topics (multicast). diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index 9085fa8dc84a..a4a15c2189fd 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -28,25 +28,25 @@ rules: metric: memory.destination.usage unit: By type: updowncounter - desc: The amount of used memory + desc: The amount of used memory by this destination # activemq.memory.destination.limit MemoryLimit: metric: memory.destination.limit unit: By type: updowncounter - desc: The amount of configured memory limit + desc: The amount of configured memory limit for this destination # activemq.temp.destination.utilization TempUsagePercentUsage: metric: temp.destination.utilization unit: "1" type: gauge - desc: The percentage of non-persistent storage used + desc: The percentage of non-persistent storage used by this destination # activemq.temp.destination.limit TempUsageLimit: metric: temp.destination.limit unit: By type: updowncounter - desc: The amount of configured non-persistent storage limit + desc: The amount of configured non-persistent storage limit for this destination # activemq.message.queue.size QueueSize: metric: message.queue.size diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index d521712677c5..4cd0d383844f 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -134,7 +134,7 @@ private static MetricsVerifier createMetricsVerifier() { .isUpDownCounter() .hasUnit("By") .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The amount of used memory")) + .hasDescription("The amount of used memory by this destination")) .add( "activemq.memory.destination.limit", metric -> @@ -142,7 +142,7 @@ private static MetricsVerifier createMetricsVerifier() { .isUpDownCounter() .hasUnit("By") .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The amount of configured memory limit")) + .hasDescription("The amount of configured memory limit for this destination")) .add( "activemq.temp.destination.utilization", metric -> @@ -150,7 +150,7 @@ private static MetricsVerifier createMetricsVerifier() { .isGauge() .hasUnit("1") .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The percentage of non-persistent storage used")) + .hasDescription("The percentage of non-persistent storage used by this destination")) .add( "activemq.temp.destination.limit", metric -> @@ -158,7 +158,7 @@ private static MetricsVerifier createMetricsVerifier() { .isUpDownCounter() .hasUnit("By") .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The amount of configured non-persistent storage limit")) + .hasDescription("The amount of configured non-persistent storage limit for this destination")) // broker metrics .add( "activemq.connection.count", From 7b63be15d65fafe0c2dda3fff57dcd57b092aae7 Mon Sep 17 00:00:00 2001 From: otelbot <197425009+otelbot@users.noreply.github.com> Date: Wed, 15 Oct 2025 20:34:36 +0000 Subject: [PATCH 16/19] ./gradlew spotlessApply --- .../instrumentation/jmx/rules/ActiveMqTest.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index 4cd0d383844f..b9692ff5f96c 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -124,8 +124,7 @@ private static MetricsVerifier createMetricsVerifier() { .isGauge() .hasUnit("s") .hasDataPointsWithAttributes(topicAttributes) - .hasDescription( - "The average time a message was held on this destination")) + .hasDescription("The average time a message was held on this destination")) // destination memory/temp usage and limits .add( "activemq.memory.destination.usage", @@ -150,7 +149,8 @@ private static MetricsVerifier createMetricsVerifier() { .isGauge() .hasUnit("1") .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The percentage of non-persistent storage used by this destination")) + .hasDescription( + "The percentage of non-persistent storage used by this destination")) .add( "activemq.temp.destination.limit", metric -> @@ -158,7 +158,8 @@ private static MetricsVerifier createMetricsVerifier() { .isUpDownCounter() .hasUnit("By") .hasDataPointsWithAttributes(topicAttributes) - .hasDescription("The amount of configured non-persistent storage limit for this destination")) + .hasDescription( + "The amount of configured non-persistent storage limit for this destination")) // broker metrics .add( "activemq.connection.count", From 774d83519bd36bcdbc131b7c8c4d676177c6a80f Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Thu, 23 Oct 2025 11:14:17 +0200 Subject: [PATCH 17/19] remove 'messaging.system' --- .../library/src/main/resources/jmx/rules/activemq.yaml | 2 -- .../instrumentation/jmx/rules/ActiveMqTest.java | 7 ++----- 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index a4a15c2189fd..c892a49ab681 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -5,7 +5,6 @@ rules: - bean: org.apache.activemq:type=Broker,brokerName=*,destinationType=*,destinationName=* metricAttribute: messaging.destination.name: param(destinationName) - messaging.system: const(activemq) # 'topic' or 'queue' activemq.destination.type: lowercase(param(destinationType)) activemq.broker.name: param(brokerName) @@ -82,7 +81,6 @@ rules: # Broker-level metrics - bean: org.apache.activemq:type=Broker,brokerName=* metricAttribute: - messaging.system: const(activemq) activemq.broker.name: param(brokerName) prefix: activemq. mapping: diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index b9692ff5f96c..ef241ab4c295 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -53,17 +53,14 @@ void activemqTest() { private static MetricsVerifier createMetricsVerifier() { - AttributeMatcher messagingSystem = attribute("messaging.system", "activemq"); // known attributes from the single topic available by default AttributeMatcher destinationName = attribute("messaging.destination.name", "ActiveMQ.Advisory.MasterBroker"); AttributeMatcher topic = attribute("activemq.destination.type", "topic"); AttributeMatcher broker = attribute("activemq.broker.name", "localhost"); - AttributeMatcherGroup topicAttributes = - attributeGroup(messagingSystem, destinationName, topic, broker); - - AttributeMatcherGroup brokerAttributes = attributeGroup(messagingSystem, broker); + AttributeMatcherGroup topicAttributes = attributeGroup(destinationName, topic, broker); + AttributeMatcherGroup brokerAttributes = attributeGroup(broker); return MetricsVerifier.create() // consumers and producers From 55841a47f475d4fb5fe6888278cb1a66a6030d59 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Thu, 23 Oct 2025 11:20:07 +0200 Subject: [PATCH 18/19] update doc --- .../jmx-metrics/library/activemq.md | 41 +++++++++---------- 1 file changed, 20 insertions(+), 21 deletions(-) diff --git a/instrumentation/jmx-metrics/library/activemq.md b/instrumentation/jmx-metrics/library/activemq.md index cd1cf0197954..e51cf253e41e 100644 --- a/instrumentation/jmx-metrics/library/activemq.md +++ b/instrumentation/jmx-metrics/library/activemq.md @@ -4,30 +4,29 @@ Here is the list of metrics based on MBeans exposed by ActiveMQ. For now, only ActiveMQ classic is supported. -| Metric Name | Type | Unit | Attributes | Description | -|-------------------------------------------|---------------|--------------|-----------------------------------------------------------------------------------------------|-----------------------------------------------------------------------| -| activemq.producer.count | UpDownCounter | {producer} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of producers attached to this destination | -| activemq.consumer.count | UpDownCounter | {consumer} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of consumers subscribed to this destination | -| activemq.memory.destination.usage | UpDownCounter | By | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of used memory by this destination | -| activemq.memory.destination.limit | UpDownCounter | By | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured memory limit for this destination | -| activemq.temp.destination.utilization | gauge | 1 | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The percentage of non-persistent storage used by this destination | -| activemq.temp.destination.limit | UpDownCounter | By | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured non-persistent storage limit | -| activemq.message.queue.size | UpDownCounter | {message} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The current number of messages waiting to be consumed | -| activemq.message.expired | Counter | {message} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages not delivered because they expired | -| activemq.message.enqueued | Counter | {message} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages sent to this destination | -| activemq.message.dequeued | Counter | {message} | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages acknowledged and removed from this destination | -| activemq.message.enqueue.average_duration | Gauge | s | messaging.system, messaging.destination.name, activemq.broker.name, activemq.destination.type | The average time a message was held on this destination | -| activemq.connection.count | UpDownCounter | {connection} | messaging.system, activemq.broker.name | The number of active connections | -| activemq.memory.utilization | Gauge | 1 | messaging.system, activemq.broker.name | The percentage of broker memory used | -| activemq.memory.limit | UpDownCounter | By | messaging.system, activemq.broker.name | The amount of configured broker memory limit | -| activemq.store.utilization | Gauge | 1 | messaging.system, activemq.broker.name | The percentage of broker persistent storage used | -| activemq.store.limit | UpDownCounter | By | messaging.system, activemq.broker.name | The amount of configured broker persistent storage limit | -| activemq.temp.utilization | Gauge | 1 | messaging.system, activemq.broker.name | The percentage of broker non-persistent storage used | -| activemq.temp.limit | UpDownCounter | By | messaging.system, activemq.broker.name | The amount of configured broker non-persistent storage limit | +| Metric Name | Type | Unit | Attributes | Description | +|-------------------------------------------|---------------|--------------|-----------------------------------------------------------------------------|-----------------------------------------------------------------------| +| activemq.producer.count | UpDownCounter | {producer} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of producers attached to this destination | +| activemq.consumer.count | UpDownCounter | {consumer} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of consumers subscribed to this destination | +| activemq.memory.destination.usage | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of used memory by this destination | +| activemq.memory.destination.limit | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured memory limit for this destination | +| activemq.temp.destination.utilization | Gauge | 1 | messaging.destination.name, activemq.broker.name, activemq.destination.type | The fraction of non-persistent storage used by this destination | +| activemq.temp.destination.limit | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured non-persistent storage limit | +| activemq.message.queue.size | UpDownCounter | {message} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The current number of messages waiting to be consumed | +| activemq.message.expired | Counter | {message} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages not delivered because they expired | +| activemq.message.enqueued | Counter | {message} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages sent to this destination | +| activemq.message.dequeued | Counter | {message} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages acknowledged and removed from this destination | +| activemq.message.enqueue.average_duration | Gauge | s | messaging.destination.name, activemq.broker.name, activemq.destination.type | The average time a message was held on this destination | +| activemq.connection.count | UpDownCounter | {connection} | activemq.broker.name | The number of active connections | +| activemq.memory.utilization | Gauge | 1 | activemq.broker.name | The fraction of broker memory used | +| activemq.memory.limit | UpDownCounter | By | activemq.broker.name | The amount of configured broker memory limit | +| activemq.store.utilization | Gauge | 1 | activemq.broker.name | The fraction of broker persistent storage used | +| activemq.store.limit | UpDownCounter | By | activemq.broker.name | The amount of configured broker persistent storage limit | +| activemq.temp.utilization | Gauge | 1 | activemq.broker.name | The fraction of broker non-persistent storage used | +| activemq.temp.limit | UpDownCounter | By | activemq.broker.name | The amount of configured broker non-persistent storage limit | ## Attributes -- `messaging.system` is always set to `activemq` ([semconv](https://opentelemetry.io/docs/specs/semconv/registry/attributes/messaging/#messaging-system)) - `messaging.destination.name` contains the destination.name ([semconv](https://opentelemetry.io/docs/specs/semconv/registry/attributes/messaging/#messaging-destination-name)) - `activemq.broker.name` contains the name of the broker - `activemq.destination.type` is set to `queue` for queues (point-to-point), `topic` for topics (multicast). From 4fc2dca9c438ccd24c936c8c8dba4cef025bf290 Mon Sep 17 00:00:00 2001 From: Sylvain Juge <763082+SylvainJuge@users.noreply.github.com> Date: Thu, 23 Oct 2025 11:49:21 +0200 Subject: [PATCH 19/19] post-review changes --- instrumentation/jmx-metrics/library/activemq.md | 8 ++++---- .../src/main/resources/jmx/rules/activemq.yaml | 16 ++++++++-------- .../instrumentation/jmx/rules/ActiveMqTest.java | 8 ++++---- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/instrumentation/jmx-metrics/library/activemq.md b/instrumentation/jmx-metrics/library/activemq.md index e51cf253e41e..db17c8fa2d3b 100644 --- a/instrumentation/jmx-metrics/library/activemq.md +++ b/instrumentation/jmx-metrics/library/activemq.md @@ -8,10 +8,10 @@ For now, only ActiveMQ classic is supported. |-------------------------------------------|---------------|--------------|-----------------------------------------------------------------------------|-----------------------------------------------------------------------| | activemq.producer.count | UpDownCounter | {producer} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of producers attached to this destination | | activemq.consumer.count | UpDownCounter | {consumer} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of consumers subscribed to this destination | -| activemq.memory.destination.usage | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of used memory by this destination | -| activemq.memory.destination.limit | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured memory limit for this destination | -| activemq.temp.destination.utilization | Gauge | 1 | messaging.destination.name, activemq.broker.name, activemq.destination.type | The fraction of non-persistent storage used by this destination | -| activemq.temp.destination.limit | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured non-persistent storage limit | +| activemq.destination.memory.usage | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of used memory by this destination | +| activemq.destination.memory.limit | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured memory limit for this destination | +| activemq.destination.temp.utilization | Gauge | 1 | messaging.destination.name, activemq.broker.name, activemq.destination.type | The fraction of non-persistent storage used by this destination | +| activemq.destination.temp.limit | UpDownCounter | By | messaging.destination.name, activemq.broker.name, activemq.destination.type | The amount of configured non-persistent storage limit | | activemq.message.queue.size | UpDownCounter | {message} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The current number of messages waiting to be consumed | | activemq.message.expired | Counter | {message} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages not delivered because they expired | | activemq.message.enqueued | Counter | {message} | messaging.destination.name, activemq.broker.name, activemq.destination.type | The number of messages sent to this destination | diff --git a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml index c892a49ab681..217cf40d11c8 100644 --- a/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml +++ b/instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/activemq.yaml @@ -22,27 +22,27 @@ rules: unit: "{consumer}" type: updowncounter desc: The number of consumers subscribed to this destination - # activemq.memory.destination.usage + # activemq.destination.memory.usage MemoryUsageByteCount: - metric: memory.destination.usage + metric: destination.memory.usage unit: By type: updowncounter desc: The amount of used memory by this destination - # activemq.memory.destination.limit + # activemq.destination.memory.limit MemoryLimit: - metric: memory.destination.limit + metric: destination.memory.limit unit: By type: updowncounter desc: The amount of configured memory limit for this destination - # activemq.temp.destination.utilization + # activemq.destination.temp.utilization TempUsagePercentUsage: - metric: temp.destination.utilization + metric: destination.temp.utilization unit: "1" type: gauge desc: The percentage of non-persistent storage used by this destination - # activemq.temp.destination.limit + # activemq.destination.temp.limit TempUsageLimit: - metric: temp.destination.limit + metric: destination.temp.limit unit: By type: updowncounter desc: The amount of configured non-persistent storage limit for this destination diff --git a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java index ef241ab4c295..1612868927b5 100644 --- a/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java +++ b/instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/ActiveMqTest.java @@ -124,7 +124,7 @@ private static MetricsVerifier createMetricsVerifier() { .hasDescription("The average time a message was held on this destination")) // destination memory/temp usage and limits .add( - "activemq.memory.destination.usage", + "activemq.destination.memory.usage", metric -> metric .isUpDownCounter() @@ -132,7 +132,7 @@ private static MetricsVerifier createMetricsVerifier() { .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The amount of used memory by this destination")) .add( - "activemq.memory.destination.limit", + "activemq.destination.memory.limit", metric -> metric .isUpDownCounter() @@ -140,7 +140,7 @@ private static MetricsVerifier createMetricsVerifier() { .hasDataPointsWithAttributes(topicAttributes) .hasDescription("The amount of configured memory limit for this destination")) .add( - "activemq.temp.destination.utilization", + "activemq.destination.temp.utilization", metric -> metric .isGauge() @@ -149,7 +149,7 @@ private static MetricsVerifier createMetricsVerifier() { .hasDescription( "The percentage of non-persistent storage used by this destination")) .add( - "activemq.temp.destination.limit", + "activemq.destination.temp.limit", metric -> metric .isUpDownCounter()