---
title: Quarkus
description: Monitor your application built with Quarkus.
breadcrumbs: Docs > Integrations > Quarkus
---

# Quarkus
Supported OS Integration version2.3.0
## Overview{% #overview %}

This check monitors [Quarkus](https://quarkus.io/) through the Datadog Agent.

**Minimum Agent version:** 7.62.0

## Setup{% #setup %}

Follow the instructions below to install and configure this check for an Agent running on a host. For containerized environments, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations/) for guidance on applying these instructions.

### Installation{% #installation %}

The Quarkus check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package starting with Agent 7.62. No additional installation is needed on your server.

### Configuration{% #configuration %}

Follow [these steps](https://quarkus.io/guides/telemetry-micrometer-tutorial) to set up metric generation in Quarkus.

Then configure the Agent:

1. Edit the `quarkus.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your Quarkus performance data. See the [sample quarkus.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/quarkus/datadog_checks/quarkus/data/conf.yaml.example) for all available configuration options.

1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent).

#### Collecting Logs{% #collecting-logs %}

Follow [these steps](https://quarkus.io/guides/logging) to configure Quarkus to emit logs.

Collecting logs is disabled by default in the Datadog Agent. Enable it in your `datadog.yaml` file:

```yaml
logs_enabled: true
```

Edit the `logs` section of your `quarkus.d/conf.yaml` file to start collecting your RabbitMQ logs:

```yaml
logs:
 - type: file
   path: /var/log/application.log
   source: quarkus
   service: quarkus-app
```

### Validation{% #validation %}

[Run the Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information) and look for `quarkus` under the Checks section.

## Data Collected{% #data-collected %}

### Metrics{% #metrics %}

|  |
|  |
| **quarkus.http\_server.active\_requests**(gauge)              | Requests to the server that are active right now.*Shown as request*                                                                                                               |
| **quarkus.http\_server.bytes\_read.count**(count)             | Number of times some bytes were received by the server.                                                                                                                           |
| **quarkus.http\_server.bytes\_read.max**(gauge)               | Maximum number of bytes currently received by the server.*Shown as byte*                                                                                                          |
| **quarkus.http\_server.bytes\_read.sum**(count)               | Total number of bytes received by the server since it started.*Shown as byte*                                                                                                     |
| **quarkus.http\_server.bytes\_written.count**(count)          | Number of times some bytes were by the server.                                                                                                                                    |
| **quarkus.http\_server.bytes\_written.max**(gauge)            | Current maximum number of bytes sent by the server.*Shown as byte*                                                                                                                |
| **quarkus.http\_server.bytes\_written.sum**(count)            | Total number of bytes sent by the server.*Shown as byte*                                                                                                                          |
| **quarkus.http\_server.connections.seconds.max**(gauge)       | The duration of the connections in seconds.*Shown as second*                                                                                                                      |
| **quarkus.http\_server.requests.seconds.count**(count)        | The number of requests observed so far.                                                                                                                                           |
| **quarkus.http\_server.requests.seconds.max**(gauge)          | The current longest request duration in seconds.*Shown as second*                                                                                                                 |
| **quarkus.http\_server.requests.seconds.sum**(count)          | Total number of seconds that all requests took so far.*Shown as second*                                                                                                           |
| **quarkus.jvm.buffer.count\_buffers**(gauge)                  | An estimate of the number of buffers in the pool.*Shown as buffer*                                                                                                                |
| **quarkus.jvm.buffer.memory\_used.bytes**(gauge)              | An estimate of the memory that the Java virtual machine is using for this buffer pool.*Shown as byte*                                                                             |
| **quarkus.jvm.buffer.total\_capacity.bytes**(gauge)           | An estimate of the total capacity of the buffers in this pool.*Shown as byte*                                                                                                     |
| **quarkus.jvm.classes.loaded\_classes**(gauge)                | The number of classes that are currently loaded in the Java virtual machine.                                                                                                      |
| **quarkus.jvm.gc.live\_data\_size.bytes**(gauge)              | Size of long-lived heap memory pool after reclamation.*Shown as byte*                                                                                                             |
| **quarkus.jvm.gc.max\_data\_size.bytes**(gauge)               | Max size of long-lived heap memory pool.*Shown as byte*                                                                                                                           |
| **quarkus.jvm.gc.overhead**(gauge)                            | 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].             |
| **quarkus.jvm.memory.committed.bytes**(gauge)                 | The amount of memory in bytes that is committed for the Java virtual machine to use.*Shown as byte*                                                                               |
| **quarkus.jvm.memory.max.bytes**(gauge)                       | The maximum amount of memory in bytes that can be used for memory management.*Shown as byte*                                                                                      |
| **quarkus.jvm.memory.usage\_after\_gc**(gauge)                | The percentage of long-lived heap pool used after the last GC event, in the range [0..1].*Shown as fraction*                                                                      |
| **quarkus.jvm.memory.used.bytes**(gauge)                      | The amount of used memory.*Shown as byte*                                                                                                                                         |
| **quarkus.jvm.threads.daemon\_threads**(gauge)                | The current number of live daemon threads.*Shown as thread*                                                                                                                       |
| **quarkus.jvm.threads.live\_threads**(gauge)                  | The current number of live threads including both daemon and non-daemon threads.*Shown as thread*                                                                                 |
| **quarkus.jvm.threads.peak\_threads**(gauge)                  | The peak live thread count since the Java virtual machine started or peak was reset.*Shown as thread*                                                                             |
| **quarkus.jvm.threads.states\_threads**(gauge)                | The current number of threads.*Shown as thread*                                                                                                                                   |
| **quarkus.netty.allocator.memory.pinned**(gauge)              | Size, in bytes, of the memory that the allocated buffer uses.*Shown as byte*                                                                                                      |
| **quarkus.netty.allocator.memory.used**(gauge)                | Size, in bytes, of the memory that the allocator uses.*Shown as byte*                                                                                                             |
| **quarkus.netty.allocator.pooled.arenas**(gauge)              | Number of arenas for a pooled allocator.*Shown as byte*                                                                                                                           |
| **quarkus.netty.allocator.pooled.cache\_size**(gauge)         | Size, in bytes, of the cache for a pooled allocator.*Shown as byte*                                                                                                               |
| **quarkus.netty.allocator.pooled.chunk\_size**(gauge)         | Size, in bytes, of memory chunks for a pooled allocator.*Shown as byte*                                                                                                           |
| **quarkus.netty.allocator.pooled.threadlocal\_caches**(gauge) | Number of ThreadLocal caches for a pooled allocator.                                                                                                                              |
| **quarkus.netty.eventexecutor.tasks\_pending**(gauge)         | Number of pending tasks in the event executor.*Shown as task*                                                                                                                     |
| **quarkus.process.cpu.usage**(gauge)                          | The recent cpu usage for the Java Virtual Machine process.                                                                                                                        |
| **quarkus.process.files.max\_files**(gauge)                   | The maximum file descriptor count.*Shown as file*                                                                                                                                 |
| **quarkus.process.files.open\_files**(gauge)                  | The open file descriptor count.*Shown as file*                                                                                                                                    |
| **quarkus.process.uptime.seconds**(gauge)                     | The uptime of the Java virtual machine.*Shown as second*                                                                                                                          |
| **quarkus.system.cpu.count**(gauge)                           | The number of processors available to the Java virtual machine.                                                                                                                   |
| **quarkus.system.cpu.usage**(gauge)                           | The recent cpu usage of the system the application is running in.                                                                                                                 |
| **quarkus.system.load\_average\_1m**(gauge)                   | 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. |
| **quarkus.worker\_pool.active**(gauge)                        | The number of resources from the pool currently used.                                                                                                                             |
| **quarkus.worker\_pool.idle**(gauge)                          | The number of resources from the pool currently used.                                                                                                                             |
| **quarkus.worker\_pool.queue.delay.seconds.count**(count)     | Number of items that spent time in the waiting queue before being processed.                                                                                                      |
| **quarkus.worker\_pool.queue.delay.seconds.max**(gauge)       | Current maximum time spent in the waiting queue before being processed.*Shown as second*                                                                                          |
| **quarkus.worker\_pool.queue.delay.seconds.sum**(count)       | Total time spent in the waiting queue before being processed.                                                                                                                     |
| **quarkus.worker\_pool.queue.size**(gauge)                    | Number of pending elements in the waiting queue.                                                                                                                                  |
| **quarkus.worker\_pool.ratio**(gauge)                         | Ratio of workers being used at the moment.*Shown as fraction*                                                                                                                     |
| **quarkus.worker\_pool.usage.seconds.count**(count)           | Number of times resources from the pool were being used.*Shown as second*                                                                                                         |
| **quarkus.worker\_pool.usage.seconds.max**(gauge)             | Maximum time spent using resources from the pool.*Shown as second*                                                                                                                |
| **quarkus.worker\_pool.usage.seconds.sum**(count)             | Total time spent using resources from the pool.*Shown as second*                                                                                                                  |

### Events{% #events %}

The Quarkus integration does not include any events.

### Service Checks{% #service-checks %}

**quarkus.openmetrics.health**

Returns `CRITICAL` if the Agent is unable to connect to the Quarkus OpenMetrics endpoint, otherwise returns `OK`.

*Statuses: ok, critical*

## Troubleshooting{% #troubleshooting %}

Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).
