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](javaagent/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

@@ -33,12 +33,7 @@ class JmxMetricInsightInstallerTest {
   private static final Set<String> FILES_TO_BE_TESTED =
       new HashSet<>(
           Arrays.asList(
-              "activemq.yaml",
-              "camel.yaml",
-              "hadoop.yaml",
-              "jetty.yaml",
-              "kafka-broker.yaml",
-              "wildfly.yaml"));
+              "activemq.yaml", "camel.yaml", "hadoop.yaml", "jetty.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/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);
 

instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/rules/TargetSystemTest.java

@@ -56,11 +56,13 @@ public class TargetSystemTest {
   private static final Logger targetSystemLogger = LoggerFactory.getLogger("targetSystem");
 
   private static final String AGENT_PATH = "/opentelemetry-instrumentation-javaagent.jar";
+  protected static final String APP_PATH = "/testapp.war";
 
   private static final Network network = Network.newNetwork();
 
   private static OtlpGrpcServer otlpServer;
   private static Path agentPath;
+  private static Path testAppPath;
   private static String otlpEndpoint;
 
   private GenericContainer<?> targetSystem;
@@ -73,10 +75,16 @@ static void beforeAll() {
     Testcontainers.exposeHostPorts(otlpServer.httpPort());
     otlpEndpoint = "http://host.testcontainers.internal:" + otlpServer.httpPort();
 
-    String path = System.getProperty("io.opentelemetry.javaagent.path");
-    assertThat(path).isNotNull();
-    agentPath = Paths.get(path);
-    assertThat(agentPath).isReadable().isNotEmptyFile();
+    TargetSystemTest.agentPath = getArtifactPath("io.opentelemetry.javaagent.path");
+    TargetSystemTest.testAppPath = getArtifactPath("io.opentelemetry.testapp.path");
+  }
+
+  private static Path getArtifactPath(String systemProperty) {
+    String pathValue = System.getProperty(systemProperty);
+    assertThat(pathValue).isNotNull();
+    Path path = Paths.get(pathValue);
+    assertThat(path).isReadable().isNotEmptyFile();
+    return path;
   }
 
   @BeforeEach
@@ -182,11 +190,12 @@ protected void startTarget(
     targetSystem.start();
   }
 
-  protected static void copyFilesToTarget(GenericContainer<?> target, List<String> yamlFiles) {
-    // copy agent to target system
+  protected static void copyAgentToTarget(GenericContainer<?> target) {
+    logger.info("copying java agent {} to container {}", agentPath, AGENT_PATH);
     target.withCopyFileToContainer(MountableFile.forHostPath(agentPath), AGENT_PATH);
+  }
 
-    // copy yaml files to target system
+  protected static void copyYamlFilesToTarget(GenericContainer<?> target, List<String> yamlFiles) {
     for (String file : yamlFiles) {
       String resourcePath = yamlResourcePath(file);
       String destPath = containerYamlPath(file);
@@ -195,6 +204,11 @@ protected static void copyFilesToTarget(GenericContainer<?> target, List<String>
     }
   }
 
+  protected static void copyTestWebAppToTarget(GenericContainer<?> target, String targetPath) {
+    logger.info("copying test application {} to container {}", testAppPath, targetPath);
+    target.withCopyFileToContainer(MountableFile.forHostPath(testAppPath), targetPath);
+  }
+
   private static String yamlResourcePath(String yaml) {
     return "jmx/rules/" + yaml;
   }