align wildfly metrics with semconv

instrumentation/jmx-metrics/README.md

@@ -30,7 +30,7 @@ No targets are enabled by default. The supported target environments are listed
 - [jetty](library/jetty.md)
 - [kafka-broker](javaagent/kafka-broker.md)
 - [tomcat](library/tomcat.md)
-- [wildfly](javaagent/wildfly.md)
+- [wildfly](library/wildfly.md)
 - [hadoop](javaagent/hadoop.md)
 
 The [jvm](library/jvm.md) metrics definitions are also included in the [jmx-metrics library](./library)

instrumentation/jmx-metrics/javaagent/src/test/java/io/opentelemetry/instrumentation/javaagent/jmx/JmxMetricInsightInstallerTest.java

@@ -32,8 +32,7 @@ class JmxMetricInsightInstallerTest {
   private static final String PATH_TO_ALL_EXISTING_RULES = "src/main/resources/jmx/rules";
   private static final Set<String> FILES_TO_BE_TESTED =
       new HashSet<>(
-          Arrays.asList(
-              "activemq.yaml", "camel.yaml", "hadoop.yaml", "kafka-broker.yaml", "wildfly.yaml"));
+          Arrays.asList("activemq.yaml", "camel.yaml", "hadoop.yaml", "kafka-broker.yaml"));
 
   @Test
   void testToVerifyExistingRulesAreValid() throws Exception {

instrumentation/jmx-metrics/library/build.gradle.kts

@@ -21,15 +21,20 @@ tasks {
   test {
     // get packaged agent jar for testing
     val shadowTask = project(":javaagent").tasks.named<ShadowJar>("shadowJar").get()
-
     dependsOn(shadowTask)
 
+    val testAppTask = project(":instrumentation:jmx-metrics:testing-webapp").tasks.named<War>("war")
+    dependsOn(testAppTask)
+
     inputs.files(layout.files(shadowTask))
       .withPropertyName("javaagent")
       .withNormalizer(ClasspathNormalizer::class)
 
     doFirst {
-      jvmArgs("-Dio.opentelemetry.javaagent.path=${shadowTask.archiveFile.get()}")
+      jvmArgs(
+        "-Dio.opentelemetry.javaagent.path=${shadowTask.archiveFile.get()}",
+        "-Dio.opentelemetry.testapp.path=${testAppTask.get().archiveFile.get().asFile.absolutePath}"
+      )
     }
   }
 }

instrumentation/jmx-metrics/library/src/main/resources/jmx/rules/wildfly.yaml

@@ -0,0 +1,147 @@
+---
+rules:
+
+  - bean: jboss.as:deployment=*,subsystem=undertow
+    prefix: wildfly.session.
+    metricAttribute:
+      wildfly.deployment: param(deployment)
+    unit: "{session}"
+    mapping:
+      # wildfly.session.created
+      sessionsCreated:
+        metric: created
+        type: counter
+        desc: The number of sessions created
+      # wildfly.session.active.count
+      activeSessions:
+        metric: active.count
+        type: updowncounter
+        desc: The number of active sessions
+      # wildfly.session.active.limit
+      maxActiveSessions:
+        metric: active.limit
+        type: updowncounter
+        desc: The maximum number of active sessions
+        # discard negative values used to indicate absence of limit
+        dropNegativeValues: true
+      # wildfly.session.expired
+      expiredSessions:
+        metric: expired
+        type: counter
+        desc: The number of expired sessions
+      # wildfly.session.rejected
+      rejectedSessions:
+        metric: rejected
+        type: counter
+        desc: The number of rejected sessions
+
+  - bean: jboss.as:subsystem=undertow,server=*,http-listener=*
+    prefix: wildfly.
+    metricAttribute:
+      wildfly.server: param(server)
+      wildfly.listener: param(http-listener)
+    type: counter
+    mapping:
+      # wildfly.request.count
+      requestCount:
+        metric: request.count
+        unit: "{request}"
+        desc: The number of requests served
+      # wildfly.request.duration.sum
+      processingTime:
+        metric: request.duration.sum
+        sourceUnit: ns
+        unit: s
+        desc: The total amount of time spent processing requests
+      # wildfly.error.count
+      errorCount:
+        metric: error.count
+        unit: "{request}"
+        desc: The number of requests that have resulted in a 5xx response
+
+  # wildly.network.io
+  - bean: jboss.as:subsystem=undertow,server=*,http-listener=*
+    metricAttribute:
+      wildfly.server: param(server)
+      wildfly.listener: param(http-listener)
+    type: counter
+    unit: By
+    mapping:
+      bytesSent:
+        metric: &metric wildfly.network.io
+        desc: &desc Total number of bytes transferred
+        metricAttribute:
+          network.io.direction: const(transmit)
+      bytesReceived:
+        metric: *metric
+        desc: *desc
+        metricAttribute:
+          network.io.direction: const(receive)
+
+  - bean: jboss.as:subsystem=datasources,data-source=*,statistics=pool
+    prefix: wildfly.db.client.connection.
+    metricAttribute:
+      db.client.connection.pool.name: param(data-source)
+    mapping:
+      # wildfly.db.client.connection.count
+      ActiveCount:
+        metric: &metric count
+        type: &type updowncounter
+        unit: &unit "{connection}"
+        desc: &desc The number of open physical database connections
+        metricAttribute:
+          db.client.connection.state: const(used)
+      IdleCount:
+        metric: *metric
+        type: *type
+        unit: *unit
+        desc: *desc
+        metricAttribute:
+          db.client.connection.state: const(idle)
+      # wildfly.db.client.connection.wait.count
+      WaitCount:
+        metric: wait.count
+        type: counter
+        # In this context, 'request' means 'connection request'
+        unit: "{request}"
+        desc: The number of connection requests that had to wait to obtain it
+
+  - bean: jboss.as:subsystem=transactions
+    prefix: wildfly.transaction.
+    unit: "{transaction}"
+    mapping:
+      # wildfly.transaction.count
+      numberOfInflightTransactions:
+        metric: count
+        type: updowncounter
+        desc: The number of in-flight transactions
+      # wildfly.transaction.created
+      numberOfTransactions:
+        metric: created
+        type: counter
+        desc: The total number of transactions created
+      # wildfly.transaction.committed
+      numberOfCommittedTransactions:
+        metric: committed
+        type: counter
+        desc: The total number of transactions committed
+      # wildfly.transaction.rollback
+      numberOfApplicationRollbacks:
+        metric: &metric rollback
+        type: &type counter
+        metricAttribute:
+          wildfly.rollback.cause: const(application)
+        desc: &desc The total number of transactions rolled back
+      numberOfResourceRollbacks:
+        metric: *metric
+        type: *type
+        metricAttribute:
+          wildfly.rollback.cause: const(resource)
+        desc: *desc
+      numberOfSystemRollbacks:
+        metric: *metric
+        type: *type
+        metricAttribute:
+          wildfly.rollback.cause: const(system)
+        desc: *desc
+

instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/JettyIntegrationTest.java → instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/JettyTest.java

@@ -19,9 +19,8 @@
 import org.junit.jupiter.params.provider.ValueSource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.wait.strategy.Wait;
-import org.testcontainers.images.builder.ImageFromDockerfile;
 
-public class JettyIntegrationTest extends TargetSystemTest {
+public class JettyTest extends TargetSystemTest {
 
   private static final int JETTY_PORT = 8080;
 
@@ -48,25 +47,20 @@ void testCollectedMetrics(int jettyMajorVersion) {
       // with older versions deployment and session management are available by default
       jettyModules.add("stats");
     }
-    String addModulesArg = "--add-to-startd=" + String.join(",", jettyModules);
+    String moduleArg = "--module=" + String.join(",", jettyModules);
 
     GenericContainer<?> container =
-        new GenericContainer<>(
-                new ImageFromDockerfile()
-                    .withDockerfileFromBuilder(
-                        builder ->
-                            builder
-                                .from("jetty:" + jettyMajorVersion)
-                                .run("java", "-jar", "/usr/local/jetty/start.jar", addModulesArg)
-                                .run("mkdir -p /var/lib/jetty/webapps/ROOT/")
-                                .run("touch /var/lib/jetty/webapps/ROOT/index.html")
-                                .build()))
+        new GenericContainer<>("jetty:" + jettyMajorVersion)
+            .withCommand(moduleArg)
             .withEnv("JAVA_OPTIONS", String.join(" ", jvmArgs))
             .withStartupTimeout(Duration.ofMinutes(2))
             .withExposedPorts(JETTY_PORT)
             .waitingFor(Wait.forListeningPorts(JETTY_PORT));
 
-    copyFilesToTarget(container, yamlFiles);
+    copyAgentToTarget(container);
+    copyYamlFilesToTarget(container, yamlFiles);
+    // Deploy example web application for session-related metrics
+    copyTestWebAppToTarget(container, "/var/lib/jetty/webapps/ROOT.war");
 
     startTarget(container);
 

instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/JvmTargetSystemTest.java → instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/JvmTest.java

@@ -20,7 +20,7 @@
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.wait.strategy.Wait;
 
-class JvmTargetSystemTest extends TargetSystemTest {
+class JvmTest extends TargetSystemTest {
 
   @ParameterizedTest
   @ValueSource(
@@ -47,7 +47,8 @@ void testJvmMetrics(String image) {
             .withExposedPorts(8080)
             .waitingFor(Wait.forListeningPorts(8080));
 
-    copyFilesToTarget(target, yamlFiles);
+    copyAgentToTarget(target);
+    copyYamlFilesToTarget(target, yamlFiles);
 
     startTarget(target);