Red Hat Quarkus native applications monitoring with metrics and logs

Red Hat Quarkus is an open source Java framework optimized for GraalVM to make Java a valuable citizen in the world of microservices. Quarkus belongs to the family of full-stack frameworks tailored for Kubernetes. It includes modern Java libraries and follows the latest Java standards.

GraalVM is designed to achieve high performance in the execution of applications written in Java and other JVM languages. It offers two approaches for compiling Java code to an executable:

just-in-time (JIT) compilation
ahead-of-time (AOT) compilation to a native image
- AOT-compiled native images include only the Java code required at runtime, excluding everything else from the libraries and frameworks.
- The native images currently are not supported by OneAgent, but it can collect Micrometer metrics and logs from Quarkus native applications.

Learn how Dynatrace can monitor metrics and logs from a Quarkus application compiled as a native image.

Prerequisites

Your GraalVM version is supported by Dynatrace.
GraalVM is configured to build native images. For details, see the Building a native executable Quarkus guide.
OneAgent or Dynatrace Operator is installed on the machine where the application is about to be executed.

The required installation depends on your application:

If your application is running See the instruction for
on a virtual machine or bare-metal OneAgent
as workload in Kubernetes or OpenShift Dynatrace Operator

If your application is running	See the instruction for
on a virtual machine or bare-metal	OneAgent
as workload in Kubernetes or OpenShift	Dynatrace Operator

Traces

Dynatrace can automatically trace JIT-compiled Quarkus applications executed on OpenJDK HotSpot JVM and GraalVM.

Trace AOT-compiled Quarkus applications

While OneAgent can only trace JIT-compiled applications, you can still export the default Quarkus tracing information using OpenTelemetry. To do so, use the Quarkus-specific configuration parameters to configure the exporter to send trace data to one of the two available endpoints, ActiveGate or OneAgent.

The following example shows how to configure application.properties to export to a Dynatrace SaaS endpoint. It specifies the API URL and the necessary, percent-encoded Authorization header with the API token.

1quarkus.application.name=myservice
2quarkus.otel.exporter.otlp.traces.endpoint=https://{your-environment-id}.live.dynatrace.com/api/v2/otlp
3quarkus.otel.exporter.otlp.traces.headers=authorization=Api-Token%20dt.....
4quarkus.log.console.format=%d{HH:mm:ss} %-5p traceId=%X{traceId}, parentId=%X{parentId}, spanId=%X{spanId}, sampled=%X{sampled} [%c{2.}] (%t) %s%e%n

Metrics

Red Hat recommends that you obtain metrics from Quarkus via the quarkus-micrometer-registry-prometheus library.

To learn how to utilize Micrometer metrics in your Quarkus application, see the Micrometer metrics Quarkus guide.

Dynatrace offers two approaches for obtaining Micrometer metrics from Prometheus: via API or via an extension.

Ingest Micrometer metrics via Dynatrace API

Use the Dynatrace API to ingest metrics obtained from the quarkus-micrometer-resistry-prometheus library.

To learn more about the ingestion procedure, see Send Micrometer metrics to Dynatrace.

For natively built applications, be sure to follow the Directly in Micrometer approach.

Ingest Micrometer metrics via an extension

Use the Dynatrace Extension 2.0 Framework to ingest Micrometer metrics obtained from the Prometheus data source—you need to create a custom extension for that.

As a starting point, you can use the custom extension example below. It's tailored to the quarkus-micrometer-resistry-prometheus library. Be sure to use the correct metrics endpoint in your configuration. The default endpoint is localhost:8080/q/metrics.

1name: custom:com.dynatrace.extension.micrometer-quarkus
2version: 1.0.0
3minDynatraceVersion: "1.247"
4author:
5  name: Dynatrace
6
7#dashboards:
8#  - path: "dashboards/dashboard_exporter.json"
9
10#alerts:
11#  - path: "alerts/alert_socket_usage.json"
12
13prometheus:
14  - group: quarkus metrics
15    interval:
16      minutes: 1
17    featureSet: all
18    dimensions:
19      - key: quarkus
20        value: const:quarkus
21    subgroups:
22      # global counters
23      - subgroup: quarkus global counter
24        dimensions:
25          - key: global_counters
26            value: const:global_counters
27        metrics:
28          # HELP process_uptime_seconds The uptime of the Java virtual machine
29          # TYPE process_uptime_seconds gauge
30          - key: com.dynatrace.process.global.uptime.seconds
31            value: metric:process_uptime_seconds
32            type: gauge
33            featureSet: global
34
35          # HELP process_cpu_usage The "recent cpu usage" for the Java Virtual Machine process
36          # TYPE process_cpu_usage gauge
37          - key: com.dynatrace.process.global.cpu.usage
38            value: metric:process_cpu_usage
39            type: gauge
40            featureSet: global
41
42          # HELP system_cpu_usage The "recent cpu usage" of the system the application is running in
43          # TYPE system_cpu_usage gauge
44          - key: com.dynatrace.system.global.cpu.usage
45            value: metric:system_cpu_usage
46            type: gauge
47            featureSet: global
48
49          # HELP jvm_classes_unloaded_classes_total The total number of classes unloaded since the Java virtual machine has started execution
50          # TYPE jvm_classes_unloaded_classes_total counter
51          - key: com.dynatrace.jvm.classes.global.uploaded.total
52            value: metric:jvm_classes_unloaded_classes_total
53            type: count
54            featureSet: global
55
56          # HELP jvm_info_total JVM version info
57          # TYPE jvm_info_total counter
58          - key: com.dynatrace.jvm.global.info.total
59            value: metric:jvm_info_total
60            type: count
61            featureSet: global
62
63          # HELP http_server_connections_seconds_max
64          # TYPE http_server_connections_seconds_max gauge
65          - key: com.dynatrace.http.server.connections.seconds.global.max
66            value: metric:http_server_connections_seconds_max
67            type: gauge
68            featureSet: global
69
70          # HELP http_server_connections_seconds
71          # TYPE http_server_connections_seconds summary
72          - key: com.dynatrace.http.server.connections.seconds.active.global.count
73            value: metric:http_server_connections_seconds_active_count
74            type: count
75            featureSet: global
76          - key: com.dynatrace.http.server.connections.seconds.active.global.duration.summary
77            value: metric:http_server_connections_seconds_duration_sum
78            type: gauge
79            featureSet: global
80
81          # HELP process_files_max_files The maximum file descriptor count
82          # TYPE process_files_max_files gauge
83          - key: com.dynatrace.process.files.global.max
84            value: metric:process_files_max_files
85            type: gauge
86            featureSet: global
87
88          # HELP http_server_bytes_written_max
89          # TYPE http_server_bytes_written_max gauge
90          - key: com.dynatrace.http.server.bytes.wrriten.global.max
91            value: metric:http_server_bytes_written_max
92            type: gauge
93            featureSet: global
94
95          # HELP http_server_bytes_written
96          # TYPE http_server_bytes_written summary
97          - key: com.dynatrace.http.server.bytes.written.global.count
98            value: metric:http_server_bytes_written_count
99            type: count
100            featureSet: global
101          - key: com.dynatrace.http.server.bytes.written.global.summary
102            value: metric:http_server_bytes_written_sum
103            type: gauge
104            featureSet: global
105
106          # HELP system_load_average_1m The sum of the number of runnable entities queued to available processors and the number of runnable entities running on the available processors averaged over a period of time
107          # TYPE system_load_average_1m gauge
108          - key: com.dynatrace.system.load.average.global.lm
109            value: metric:system_load_average_1m
110            type: gauge
111            featureSet: global
112
113          # HELP jvm_gc_overhead_percent An approximation of the percent of CPU time used by GC activities over the last lookback period or since monitoring began, whichever is shorter, in the range [0..1]
114          # TYPE jvm_gc_overhead_percent gauge
115          - key: com.dynatrace.jvm.gc.overhead.global.percent
116            value: metric:jvm_gc_overhead_percent
117            type: gauge
118            featureSet: global
119
120          # HELP jvm_threads_daemon_threads The current number of live daemon threads
121          # TYPE jvm_threads_daemon_threads gauge
122          - key: com.dynatrace.jvm.threads.daemon.global.threads
123            value: metric:jvm_threads_daemon_threads
124            type: gauge
125            featureSet: global
126
127          # HELP jvm_threads_live_threads The current number of live threads including both daemon and non-daemon threads
128          # TYPE jvm_threads_live_threads gauge
129          - key: com.dynatrace.jvm.threads.live.global.threads
130            value: metric:jvm_threads_live_threads
131            type: gauge
132            featureSet: global
133
134          # HELP http_server_requests_seconds
135          # TYPE http_server_requests_seconds summary
136          - key: com.dynatrace.http.server.bytes.written.global.count
137            value: metric:http_server_requests_seconds_count
138            type: count
139            featureSet: global
140          - key: com.dynatrace.http.server.bytes.written.global.summary
141            value: metric:http_server_requests_seconds_sum
142            type: gauge
143            featureSet: global
144
145          # HELP http_server_requests_seconds_max
146          # TYPE http_server_requests_seconds_max gauge
147          - key: com.dynatrace.http.server.requests.seconds.max
148            value: metric:http_server_requests_seconds_max
149            type: gauge
150            featureSet: global
151
152          # HELP process_start_time_seconds Start time of the process since unix epoch.
153          # TYPE process_start_time_seconds gauge
154          - key: com.dynatrace.process.start.time.global.seconds
155            value: metric:process_start_time_seconds
156            type: gauge
157            featureSet: global
158
159          # HELP jvm_classes_loaded_classes The number of classes that are currently loaded in the Java virtual machine
160          # TYPE jvm_classes_loaded_classes gauge
161          - key: com.dynatrace.jvm.classes.loaded.global.max
162            value: metric:jvm_classes_loaded_classes
163            type: gauge
164            featureSet: global
165
166          # HELP jvm_threads_peak_threads The peak live thread count since the Java virtual machine started or peak was reset
167          # TYPE jvm_threads_peak_threads gauge
168          - key: com.dynatrace.jvm.threads.peak.global.threads
169            value: metric:jvm_threads_peak_threads
170            type: gauge
171            featureSet: global
172
173          # HELP system_cpu_count The number of processors available to the Java virtual machine
174          # TYPE system_cpu_count gauge
175          - key: com.dynatrace.system.cpu.global.counter
176            value: metric:system_cpu_count
177            type: gauge
178            featureSet: global
179
180          # HELP process_files_open_files The open file descriptor count
181          # TYPE process_files_open_files gauge
182          - key: com.dynatrace.process.files.open.global.files
183            value: metric:process_files_open_files
184            type: gauge
185            featureSet: global

Logs

Dynatrace offers various options for collecting logs from your applications and environments.

To learn how to set up logging in your Quarkus application, see the Configuring logging Quarkus guide.

For the procedure below, we assume your application writes logs to the /var/log/quarkus-app.log file.

Start your Quarkus native application.
In the Dynatrace menu, go to Hosts and select your host.
Scroll down to the Process analysis section and, in the list of processes, select the process of your Quarkus native application.
On the right side of the Process panel, select > Settings.
In the process group settings, select Log monitoring > Add new log for monitoring.
Enter the full path of your log file. Be sure to follow the log path requirements.
Select Save changes.
Include the added log files in your log storage.