---
title: Pulsar
description: Monitor your Pulsar clusters.
breadcrumbs: Docs > Integrations > Pulsar
---

# Pulsar
Supported OS Integration version3.6.0
## Overview{% #overview %}

This check monitors [Pulsar](https://pulsar.apache.org) through the Datadog Agent.

**Minimum Agent version:** 7.34.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 Pulsar check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed on your server.

### Configuration{% #configuration %}

1. Edit the `pulsar.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your pulsar performance data. See the [sample pulsar.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/pulsar/datadog_checks/pulsar/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).

### Validation{% #validation %}

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

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

### Metrics{% #metrics %}

|  |
|  |
| **pulsar.active\_connections**(gauge)                                  | The number of active connections.*Shown as connection*                                                                                                                                                                                                   |
| **pulsar.authentication\_failures\_count.count**(count)                | The number of failing authentication operations.                                                                                                                                                                                                         |
| **pulsar.authentication\_success\_count.count**(count)                 | The number of successful authentication operations.                                                                                                                                                                                                      |
| **pulsar.bookie\_DELETED\_LEDGER\_COUNT.count**(count)                 | The total number of ledgers deleted since the bookie has started.                                                                                                                                                                                        |
| **pulsar.bookie\_READ\_BYTES.count**(count)                            | The total number of bytes read from the bookie.*Shown as byte*                                                                                                                                                                                           |
| **pulsar.bookie\_SERVER\_STATUS**(gauge)                               | The server status for bookie server. 1: the bookie is running in writable mode.0: the bookie is running in readonly mode.                                                                                                                                |
| **pulsar.bookie\_WRITE\_BYTES.count**(count)                           | The total number of bytes written to the bookie.*Shown as byte*                                                                                                                                                                                          |
| **pulsar.bookie\_entries\_count**(gauge)                               | The total number of entries stored in the bookie.                                                                                                                                                                                                        |
| **pulsar.bookie\_flush**(gauge)                                        | The table flush latency of bookie memory.                                                                                                                                                                                                                |
| **pulsar.bookie\_journal\_JOURNAL\_CB\_QUEUE\_SIZE**(gauge)            | The total number of callbacks pending in the callback queue.                                                                                                                                                                                             |
| **pulsar.bookie\_journal\_JOURNAL\_FORCE\_WRITE\_QUEUE\_SIZE**(gauge)  | The total number of force write (fsync) requests pending in the force-write queue.*Shown as request*                                                                                                                                                     |
| **pulsar.bookie\_journal\_JOURNAL\_QUEUE\_SIZE**(gauge)                | The total number of requests pending in the journal queue.*Shown as request*                                                                                                                                                                             |
| **pulsar.bookie\_journal\_JOURNAL\_SYNC\_count.count**(count)          | The total number of journal fsync operations happening at the bookie. The success label is used to distinguish successes and failures.                                                                                                                   |
| **pulsar.bookie\_ledger\_writable\_dirs**(gauge)                       | The number of writable directories in the bookie.                                                                                                                                                                                                        |
| **pulsar.bookie\_ledgers\_count**(gauge)                               | The total number of ledgers stored in the bookie.                                                                                                                                                                                                        |
| **pulsar.bookie\_read\_cache\_size**(gauge)                            | The bookie read cache size (in bytes).*Shown as byte*                                                                                                                                                                                                    |
| **pulsar.bookie\_throttled\_write\_requests.count**(count)             | The number of write requests to be throttled.*Shown as request*                                                                                                                                                                                          |
| **pulsar.bookie\_write\_cache\_size**(gauge)                           | The bookie write cache size (in bytes).*Shown as byte*                                                                                                                                                                                                   |
| **pulsar.bookkeeper\_server\_ADD\_ENTRY\_count.count**(count)          | The total number of ADD_ENTRY requests received at the bookie. The success label is used to distinguish successes and failures.*Shown as request*                                                                                                        |
| **pulsar.bookkeeper\_server\_BOOKIE\_QUARANTINE\_count.count**(count)  | The number of bookie clients to be quarantined.                                                                                                                                                                                                          |
| **pulsar.bookkeeper\_server\_READ\_ENTRY\_count.count**(count)         | The total number of READ_ENTRY requests received at the bookie. The success label is used to distinguish successes and failures.*Shown as request*                                                                                                       |
| **pulsar.brk\_ml\_cursor\_nonContiguousDeletedMessagesRange**(gauge)   | The number of non-contiguous deleted messages ranges.                                                                                                                                                                                                    |
| **pulsar.brk\_ml\_cursor\_persistLedgerErrors**(gauge)                 | The number of ledger errors occurred when acknowledgment states fail to be persistent to the ledger.*Shown as error*                                                                                                                                     |
| **pulsar.brk\_ml\_cursor\_persistLedgerSucceed**(gauge)                | The number of acknowledgment states that is persistent to a ledger.                                                                                                                                                                                      |
| **pulsar.brk\_ml\_cursor\_persistZookeeperErrors**(gauge)              | The number of ledger errors occurred when acknowledgment states fail to be persistent to ZooKeeper.*Shown as error*                                                                                                                                      |
| **pulsar.brk\_ml\_cursor\_persistZookeeperSucceed**(gauge)             | The number of acknowledgment states that is persistent to ZooKeeper.                                                                                                                                                                                     |
| **pulsar.brk\_ml\_cursor\_readLedgerSize**(gauge)                      | The size of read from ledger.                                                                                                                                                                                                                            |
| **pulsar.brk\_ml\_cursor\_writeLedgerLogicalSize**(gauge)              | The size of write to ledger (accounting for without replicas).                                                                                                                                                                                           |
| **pulsar.brk\_ml\_cursor\_writeLedgerSize**(gauge)                     | The size of write to ledger.                                                                                                                                                                                                                             |
| **pulsar.broker\_load\_manager\_bundle\_assignment**(gauge)            | The summary of latency of bundles ownership operations.                                                                                                                                                                                                  |
| **pulsar.broker\_lookup.count**(count)                                 | Number of samples of the latency of all lookup operations.                                                                                                                                                                                               |
| **pulsar.broker\_lookup.quantle**(count)                               | Latency of all lookup operations.                                                                                                                                                                                                                        |
| **pulsar.broker\_lookup.sum**(count)                                   | Total latency of all lookup operations.                                                                                                                                                                                                                  |
| **pulsar.broker\_lookup\_answers.count**(count)                        | The number of lookup responses (i.e. not redirected requests).*Shown as response*                                                                                                                                                                        |
| **pulsar.broker\_lookup\_failures.count**(count)                       | The number of lookup failures.                                                                                                                                                                                                                           |
| **pulsar.broker\_lookup\_pending\_requests**(gauge)                    | The number of pending lookups in broker. When it is up to the threshold, new requests are rejected.*Shown as request*                                                                                                                                    |
| **pulsar.broker\_lookup\_redirects.count**(count)                      | The number of lookup redirected requests.*Shown as request*                                                                                                                                                                                              |
| **pulsar.broker\_throttled\_connections**(gauge)                       | The number of throttled connections.*Shown as connection*                                                                                                                                                                                                |
| **pulsar.broker\_throttled\_connections\_global\_limit**(gauge)        | The number of throttled connections because of per-connection limit.*Shown as connection*                                                                                                                                                                |
| **pulsar.broker\_topic\_load\_pending\_requests**(gauge)               | The load of pending topic operations.                                                                                                                                                                                                                    |
| **pulsar.bundle\_consumer\_count**(gauge)                              | The consumer count of the topics in this bundle.                                                                                                                                                                                                         |
| **pulsar.bundle\_msg\_rate\_in**(gauge)                                | The total message rate coming into the topics in this bundle (messages/second).                                                                                                                                                                          |
| **pulsar.bundle\_msg\_rate\_out**(gauge)                               | The total message rate going out from the topics in this bundle (messages/second).                                                                                                                                                                       |
| **pulsar.bundle\_msg\_throughput\_in**(gauge)                          | The total throughput coming into the topics in this bundle (bytes/second).                                                                                                                                                                               |
| **pulsar.bundle\_msg\_throughput\_out**(gauge)                         | The total throughput going out from the topics in this bundle (bytes/second).                                                                                                                                                                            |
| **pulsar.bundle\_producer\_count**(gauge)                              | The producer count of the topics in this bundle.                                                                                                                                                                                                         |
| **pulsar.bundle\_topics\_count**(gauge)                                | The topic count in this bundle.                                                                                                                                                                                                                          |
| **pulsar.compaction\_compacted\_entries\_count**(gauge)                | The total number of the compacted entries.                                                                                                                                                                                                               |
| **pulsar.compaction\_compacted\_entries\_size**(gauge)                 | The total size of the compacted entries.                                                                                                                                                                                                                 |
| **pulsar.compaction\_duration\_time\_in\_mills**(gauge)                | The duration time of the compaction.                                                                                                                                                                                                                     |
| **pulsar.compaction\_failed\_count**(gauge)                            | The total number of failures of the compaction.                                                                                                                                                                                                          |
| **pulsar.compaction\_read\_throughput**(gauge)                         | The read throughput of the compaction.                                                                                                                                                                                                                   |
| **pulsar.compaction\_removed\_event\_count**(gauge)                    | The total number of removed events of the compaction.                                                                                                                                                                                                    |
| **pulsar.compaction\_succeed\_count**(gauge)                           | The total number of successes of the compaction.                                                                                                                                                                                                         |
| **pulsar.compaction\_write\_throughput**(gauge)                        | The write throughput of the compaction.                                                                                                                                                                                                                  |
| **pulsar.connection\_closed\_total\_count**(gauge)                     | The total number of closed connections.*Shown as connection*                                                                                                                                                                                             |
| **pulsar.connection\_create\_fail\_count**(gauge)                      | The number of failed connections.*Shown as connection*                                                                                                                                                                                                   |
| **pulsar.connection\_create\_success\_count**(gauge)                   | The number of successfully created connections.*Shown as connection*                                                                                                                                                                                     |
| **pulsar.connection\_created\_total\_count**(gauge)                    | The total number of connections.*Shown as connection*                                                                                                                                                                                                    |
| **pulsar.consumer\_available\_permits**(gauge)                         | The available permits for for a consumer.                                                                                                                                                                                                                |
| **pulsar.consumer\_blocked\_on\_unacked\_messages**(gauge)             | Indicate whether a consumer is blocked on unacknowledged messages or not. 1 means the consumer is blocked on waiting unacknowledged messages to be acked.0 means the consumer is not blocked on waiting unacknowledged messages to be acked.             |
| **pulsar.consumer\_msg\_rate\_out**(gauge)                             | The total message dispatch rate for a consumer (messages/second).                                                                                                                                                                                        |
| **pulsar.consumer\_msg\_rate\_redeliver**(gauge)                       | The total message rate for message being redelivered (messages/second).                                                                                                                                                                                  |
| **pulsar.consumer\_msg\_throughput\_out**(gauge)                       | The total message dispatch throughput for a consumer (bytes/second).                                                                                                                                                                                     |
| **pulsar.consumer\_unacked\_messages**(gauge)                          | The total number of unacknowledged messages of a consumer (messages).*Shown as message*                                                                                                                                                                  |
| **pulsar.consumers\_count**(gauge)                                     | The number of active consumers of the namespace connected to this broker.                                                                                                                                                                                |
| **pulsar.expired\_token\_count.count**(count)                          | The number of expired tokens in Pulsar.                                                                                                                                                                                                                  |
| **pulsar.function\_last\_invocation**(gauge)                           | The timestamp of the last invocation of the function.                                                                                                                                                                                                    |
| **pulsar.function\_processed\_successfully\_total.count**(count)       | The total number of messages processed successfully.*Shown as message*                                                                                                                                                                                   |
| **pulsar.function\_processed\_successfully\_total\_1min.count**(count) | The total number of messages processed successfully in the last 1 minute.*Shown as message*                                                                                                                                                              |
| **pulsar.function\_received\_total.count**(count)                      | The total number of messages received from source.*Shown as message*                                                                                                                                                                                     |
| **pulsar.function\_received\_total\_1min.count**(count)                | The total number of messages received from source in the last 1 minute.*Shown as message*                                                                                                                                                                |
| **pulsar.function\_system\_exceptions\_total.count**(count)            | The total number of system exceptions.                                                                                                                                                                                                                   |
| **pulsar.function\_system\_exceptions\_total\_1min.count**(count)      | The total number of system exceptions in the last 1 minute.                                                                                                                                                                                              |
| **pulsar.function\_user\_exceptions\_total.count**(count)              | The total number of user exceptions.                                                                                                                                                                                                                     |
| **pulsar.function\_user\_exceptions\_total\_1min.count**(count)        | The total number of user exceptions in the last 1 minute.                                                                                                                                                                                                |
| **pulsar.in\_bytes\_total**(gauge)                                     | The number of messages in bytes received for this topic.*Shown as byte*                                                                                                                                                                                  |
| **pulsar.in\_messages\_total**(gauge)                                  | The total number of messages received for this topic.*Shown as message*                                                                                                                                                                                  |
| **pulsar.jetty\_async\_dispatches\_total.count**(count)                | Number of requested that have been asynchronously dispatched.                                                                                                                                                                                            |
| **pulsar.jetty\_async\_requests\_total.count**(count)                  | Total number of async requests.*Shown as request*                                                                                                                                                                                                        |
| **pulsar.jetty\_async\_requests\_waiting**(gauge)                      | Currently waiting async requests.*Shown as request*                                                                                                                                                                                                      |
| **pulsar.jetty\_async\_requests\_waiting\_max**(gauge)                 | Maximum number of waiting async requests.*Shown as request*                                                                                                                                                                                              |
| **pulsar.jetty\_dispatched\_active**(gauge)                            | Number of dispatches currently active.                                                                                                                                                                                                                   |
| **pulsar.jetty\_dispatched\_active\_max**(gauge)                       | Maximum number of active dispatches being handled.                                                                                                                                                                                                       |
| **pulsar.jetty\_dispatched\_time\_max**(gauge)                         | Maximum time spent in dispatch handling.                                                                                                                                                                                                                 |
| **pulsar.jetty\_dispatched\_time\_seconds\_total.count**(count)        | Total time spent in dispatch handling.*Shown as second*                                                                                                                                                                                                  |
| **pulsar.jetty\_dispatched\_total.count**(count)                       | Number of dispatches.                                                                                                                                                                                                                                    |
| **pulsar.jetty\_expires\_total.count**(count)                          | Number of async requests requests that have expired.*Shown as request*                                                                                                                                                                                   |
| **pulsar.jetty\_request\_time\_max\_seconds**(gauge)                   | Maximum time spent handling requests.*Shown as second*                                                                                                                                                                                                   |
| **pulsar.jetty\_request\_time\_seconds\_total.count**(count)           | Total time spent in all request handling.*Shown as second*                                                                                                                                                                                               |
| **pulsar.jetty\_requests\_active**(gauge)                              | Number of requests currently active.*Shown as request*                                                                                                                                                                                                   |
| **pulsar.jetty\_requests\_active\_max**(gauge)                         | Maximum number of requests that have been active at once.*Shown as request*                                                                                                                                                                              |
| **pulsar.jetty\_requests\_total.count**(count)                         | Number of requests.*Shown as request*                                                                                                                                                                                                                    |
| **pulsar.jetty\_responses\_bytes\_total.count**(count)                 | Total number of bytes across all responses.*Shown as byte*                                                                                                                                                                                               |
| **pulsar.jetty\_responses\_total.count**(count)                        | Number of responses, labeled by status code. The code label can be "1xx", "2xx", "3xx", "4xx", or "5xx".*Shown as response*                                                                                                                              |
| **pulsar.jetty\_stats\_seconds**(gauge)                                | Time in seconds stats have been collected for.*Shown as second*                                                                                                                                                                                          |
| **pulsar.lb\_bandwidth\_in\_usage**(gauge)                             | The broker inbound bandwith usage (in percent).                                                                                                                                                                                                          |
| **pulsar.lb\_bandwidth\_out\_usage**(gauge)                            | The broker outbound bandwith usage (in percent).                                                                                                                                                                                                         |
| **pulsar.lb\_bundles\_split\_count.count**(count)                      | bundle split count in this bundle splitting check interval                                                                                                                                                                                               |
| **pulsar.lb\_cpu\_usage**(gauge)                                       | The broker cpu usage (in percent).                                                                                                                                                                                                                       |
| **pulsar.lb\_directMemory\_usage**(gauge)                              | The broker process direct memory usage (in percent).                                                                                                                                                                                                     |
| **pulsar.lb\_memory\_usage**(gauge)                                    | The broker process memory usage (in percent).                                                                                                                                                                                                            |
| **pulsar.lb\_unload\_broker\_count.count**(count)                      | Unload broker count in this bundle unloading                                                                                                                                                                                                             |
| **pulsar.lb\_unload\_bundle\_count.count**(count)                      | Bundle unload count in this bundle unloading                                                                                                                                                                                                             |
| **pulsar.ml\_AddEntryBytesRate**(gauge)                                | The bytes/s rate of messages added                                                                                                                                                                                                                       |
| **pulsar.ml\_AddEntryErrors**(gauge)                                   | The number of addEntry requests that failed*Shown as request*                                                                                                                                                                                            |
| **pulsar.ml\_AddEntryMessagesRate**(gauge)                             | The msg/s rate of messages added                                                                                                                                                                                                                         |
| **pulsar.ml\_AddEntrySucceed**(gauge)                                  | The number of addEntry requests that succeeded*Shown as request*                                                                                                                                                                                         |
| **pulsar.ml\_AddEntryWithReplicasBytesRate**(gauge)                    | The bytes/s rate of messages added with replicas                                                                                                                                                                                                         |
| **pulsar.ml\_MarkDeleteRate**(gauge)                                   | The rate of mark-delete ops/s                                                                                                                                                                                                                            |
| **pulsar.ml\_NumberOfMessagesInBacklog**(gauge)                        | The number of backlog messages for all the consumers*Shown as message*                                                                                                                                                                                   |
| **pulsar.ml\_ReadEntriesBytesRate**(gauge)                             | The bytes/s rate of messages read                                                                                                                                                                                                                        |
| **pulsar.ml\_ReadEntriesErrors**(gauge)                                | The number of readEntries requests that failed*Shown as request*                                                                                                                                                                                         |
| **pulsar.ml\_ReadEntriesRate**(gauge)                                  | The msg/s rate of messages read                                                                                                                                                                                                                          |
| **pulsar.ml\_ReadEntriesSucceeded**(gauge)                             | The number of readEntries requests that succeeded*Shown as request*                                                                                                                                                                                      |
| **pulsar.ml\_StoredMessagesSize**(gauge)                               | The total size of the messages in active ledgers (accounting for the multiple copies stored)                                                                                                                                                             |
| **pulsar.ml\_cache\_evictions**(gauge)                                 | The number of cache evictions during the last minute.*Shown as eviction*                                                                                                                                                                                 |
| **pulsar.ml\_cache\_hits\_rate**(gauge)                                | The number of cache hits per second on the broker side.*Shown as hit*                                                                                                                                                                                    |
| **pulsar.ml\_cache\_hits\_throughput**(gauge)                          | The amount of data is retrieved from the cache on the broker side (in byte/s).                                                                                                                                                                           |
| **pulsar.ml\_cache\_misses\_rate**(gauge)                              | The number of cache misses per second on the broker side.*Shown as miss*                                                                                                                                                                                 |
| **pulsar.ml\_cache\_misses\_throughput**(gauge)                        | The amount of data is not retrieved from the cache on the broker side (in byte/s).                                                                                                                                                                       |
| **pulsar.ml\_cache\_pool\_active\_allocations**(gauge)                 | The number of currently active allocations in direct arena                                                                                                                                                                                               |
| **pulsar.ml\_cache\_pool\_active\_allocations\_huge**(gauge)           | The number of currently active huge allocation in direct arena                                                                                                                                                                                           |
| **pulsar.ml\_cache\_pool\_active\_allocations\_normal**(gauge)         | The number of currently active normal allocations in direct arena                                                                                                                                                                                        |
| **pulsar.ml\_cache\_pool\_active\_allocations\_small**(gauge)          | The number of currently active small allocations in direct arena                                                                                                                                                                                         |
| **pulsar.ml\_cache\_pool\_allocated**(gauge)                           | The total allocated memory of chunk lists in direct arena                                                                                                                                                                                                |
| **pulsar.ml\_cache\_pool\_used**(gauge)                                | The total used memory of chunk lists in direct arena                                                                                                                                                                                                     |
| **pulsar.ml\_cache\_used\_size**(gauge)                                | The size in byte used to store the entries payloads*Shown as byte*                                                                                                                                                                                       |
| **pulsar.ml\_count**(gauge)                                            | The number of currently opened managed ledgers                                                                                                                                                                                                           |
| **pulsar.out\_bytes\_total**(gauge)                                    | The total number of messages in bytes read from this topic.*Shown as byte*                                                                                                                                                                               |
| **pulsar.out\_messages\_total**(gauge)                                 | The total number of messages read from this topic.*Shown as message*                                                                                                                                                                                     |
| **pulsar.producers\_count**(gauge)                                     | The number of active producers of the namespace connected to this broker.                                                                                                                                                                                |
| **pulsar.proxy\_active\_connections**(gauge)                           | Number of connections currently active in the proxy.*Shown as connection*                                                                                                                                                                                |
| **pulsar.proxy\_binary\_bytes.count**(count)                           | Counter of proxy bytes.*Shown as byte*                                                                                                                                                                                                                   |
| **pulsar.proxy\_binary\_ops.count**(count)                             | Counter of proxy operations.                                                                                                                                                                                                                             |
| **pulsar.proxy\_new\_connections.count**(count)                        | Counter of connections being opened in the proxy.*Shown as connection*                                                                                                                                                                                   |
| **pulsar.proxy\_rejected\_connections.count**(count)                   | Counter for connections rejected due to throttling.*Shown as connection*                                                                                                                                                                                 |
| **pulsar.rate\_in**(gauge)                                             | The total message rate of the namespace coming into this broker (messages/second).                                                                                                                                                                       |
| **pulsar.rate\_out**(gauge)                                            | The total message rate of the namespace going out from this broker (messages/second).                                                                                                                                                                    |
| **pulsar.replication\_backlog**(gauge)                                 | The total backlog of the namespace replicating to remote cluster (messages).*Shown as message*                                                                                                                                                           |
| **pulsar.replication\_connected\_count**(gauge)                        | The count of replication-subscriber up and running to replicate to remote cluster.                                                                                                                                                                       |
| **pulsar.replication\_delay\_in\_seconds**(gauge)                      | Time in seconds from the time a message was produced to the time when it is about to be replicated.*Shown as second*                                                                                                                                     |
| **pulsar.replication\_rate\_expired**(gauge)                           | Total rate of messages expired (messages/second).                                                                                                                                                                                                        |
| **pulsar.replication\_rate\_in**(gauge)                                | The total message rate of the namespace replicating from remote cluster (messages/second).                                                                                                                                                               |
| **pulsar.replication\_rate\_out**(gauge)                               | The total message rate of the namespace replicating to remote cluster (messages/second).                                                                                                                                                                 |
| **pulsar.replication\_throughput\_in**(gauge)                          | The total throughput of the namespace replicating from remote cluster (bytes/second).                                                                                                                                                                    |
| **pulsar.replication\_throughput\_out**(gauge)                         | The total throughput of the namespace replicating to remote cluster (bytes/second).                                                                                                                                                                      |
| **pulsar.sink\_last\_invocation**(gauge)                               | The timestamp of the last invocation of the sink.                                                                                                                                                                                                        |
| **pulsar.sink\_received\_total.count**(count)                          | The total number of records that a sink has received from Pulsar topics.                                                                                                                                                                                 |
| **pulsar.sink\_received\_total\_1min.count**(count)                    | The total number of messages that a sink has received from Pulsar topics in the last 1 minute.*Shown as message*                                                                                                                                         |
| **pulsar.sink\_sink\_exception**(gauge)                                | The exception from a sink.                                                                                                                                                                                                                               |
| **pulsar.sink\_sink\_exceptions\_total.count**(count)                  | The total number of sink exceptions.                                                                                                                                                                                                                     |
| **pulsar.sink\_sink\_exceptions\_total\_1min.count**(count)            | The total number of sink exceptions in the last 1 minute.                                                                                                                                                                                                |
| **pulsar.sink\_system\_exception**(gauge)                              | The exception from system code.                                                                                                                                                                                                                          |
| **pulsar.sink\_system\_exceptions\_total.count**(count)                | The total number of system exceptions.                                                                                                                                                                                                                   |
| **pulsar.sink\_system\_exceptions\_total\_1min.count**(count)          | The total number of system exceptions in the last 1 minute.                                                                                                                                                                                              |
| **pulsar.sink\_written\_total.count**(count)                           | The total number of records processed by a sink.                                                                                                                                                                                                         |
| **pulsar.sink\_written\_total\_1min.count**(count)                     | The total number of records processed by a sink in the last 1 minute.                                                                                                                                                                                    |
| **pulsar.source\_last\_invocation**(gauge)                             | The timestamp of the last invocation of the source.                                                                                                                                                                                                      |
| **pulsar.source\_received\_total.count**(count)                        | The total number of records received from source.                                                                                                                                                                                                        |
| **pulsar.source\_received\_total\_1min.count**(count)                  | The total number of records received from source in the last 1 minute.                                                                                                                                                                                   |
| **pulsar.source\_source\_exception**(gauge)                            | The exception from a source.                                                                                                                                                                                                                             |
| **pulsar.source\_source\_exceptions\_total.count**(count)              | The total number of source exceptions.                                                                                                                                                                                                                   |
| **pulsar.source\_source\_exceptions\_total\_1min.count**(count)        | The total number of source exceptions in the last 1 minute.                                                                                                                                                                                              |
| **pulsar.source\_system\_exception**(gauge)                            | The exception from system code.                                                                                                                                                                                                                          |
| **pulsar.source\_system\_exceptions\_total.count**(count)              | The total number of system exceptions.                                                                                                                                                                                                                   |
| **pulsar.source\_system\_exceptions\_total\_1min.count**(count)        | The total number of system exceptions in the last 1 minute.                                                                                                                                                                                              |
| **pulsar.source\_written\_total.count**(count)                         | The total number of records written to a Pulsar topic.                                                                                                                                                                                                   |
| **pulsar.source\_written\_total\_1min.count**(count)                   | The total number of records written to a Pulsar topic in the last 1 minute.                                                                                                                                                                              |
| **pulsar.split\_bytes\_read.count**(count)                             | Number of bytes read from BookKeeper.*Shown as byte*                                                                                                                                                                                                     |
| **pulsar.split\_num\_messages\_deserialized.count**(count)             | Number of messages deserialized.*Shown as message*                                                                                                                                                                                                       |
| **pulsar.split\_num\_record\_deserialized.count**(count)               | Number of records deserialized.                                                                                                                                                                                                                          |
| **pulsar.storage\_backlog\_quota\_limit**(gauge)                       | The total amount of the data in this topic that limit the backlog quota (bytes).*Shown as byte*                                                                                                                                                          |
| **pulsar.storage\_backlog\_size**(gauge)                               | The total backlog size of the topics of this namespace owned by this broker (messages).                                                                                                                                                                  |
| **pulsar.storage\_logical\_size**(gauge)                               | The storage size of topics in the namespace owned by the broker without replicas (in bytes).                                                                                                                                                             |
| **pulsar.storage\_offloaded\_size**(gauge)                             | The total amount of the data in this namespace offloaded to the tiered storage (bytes).                                                                                                                                                                  |
| **pulsar.storage\_read\_rate**(gauge)                                  | The total message batches (entries) read from the storage for this namespace (message batches / second).                                                                                                                                                 |
| **pulsar.storage\_size**(gauge)                                        | The total storage size of the topics in this namespace owned by this broker (bytes).                                                                                                                                                                     |
| **pulsar.storage\_write\_rate**(gauge)                                 | The total message batches (entries) written to the storage for this namespace (message batches / second).                                                                                                                                                |
| **pulsar.subscription\_back\_log**(gauge)                              | The total backlog of a subscription (messages).*Shown as message*                                                                                                                                                                                        |
| **pulsar.subscription\_blocked\_on\_unacked\_messages**(gauge)         | Indicate whether a subscription is blocked on unacknowledged messages or not. 1 means the subscription is blocked on waiting unacknowledged messages to be acked.0 means the subscription is not blocked on waiting unacknowledged messages to be acked. |
| **pulsar.subscription\_delayed**(gauge)                                | The total message batches (entries) are delayed for dispatching.                                                                                                                                                                                         |
| **pulsar.subscription\_msg\_rate\_out**(gauge)                         | The total message dispatch rate for a subscription (messages/second).                                                                                                                                                                                    |
| **pulsar.subscription\_msg\_rate\_redeliver**(gauge)                   | The total message rate for message being redelivered (messages/second).                                                                                                                                                                                  |
| **pulsar.subscription\_msg\_throughput\_out**(gauge)                   | The total message dispatch throughput for a subscription (bytes/second).                                                                                                                                                                                 |
| **pulsar.subscription\_unacked\_messages**(gauge)                      | The total number of unacknowledged messages of a subscription (messages).*Shown as message*                                                                                                                                                              |
| **pulsar.subscriptions\_count**(gauge)                                 | The number of Pulsar subscriptions of the namespace served by this broker.                                                                                                                                                                               |
| **pulsar.throughput\_in**(gauge)                                       | The total throughput of the namespace coming into this broker (bytes/second).                                                                                                                                                                            |
| **pulsar.throughput\_out**(gauge)                                      | The total throughput of the namespace going out from this broker (bytes/second).                                                                                                                                                                         |
| **pulsar.topics\_count**(gauge)                                        | The number of Pulsar topics of the namespace owned by this broker.                                                                                                                                                                                       |
| **pulsar.txn\_aborted\_count.count**(count)                            | Number of aborted transactions of this coordinator.*Shown as transaction*                                                                                                                                                                                |
| **pulsar.txn\_active\_count**(gauge)                                   | Number of active transactions.*Shown as transaction*                                                                                                                                                                                                     |
| **pulsar.txn\_append\_log\_count.count**(count)                        | Number of append transaction logs.                                                                                                                                                                                                                       |
| **pulsar.txn\_committed\_count.count**(count)                          | Number of committed transactions.*Shown as transaction*                                                                                                                                                                                                  |
| **pulsar.txn\_created\_count.count**(count)                            | Number of created transactions.*Shown as transaction*                                                                                                                                                                                                    |
| **pulsar.txn\_timeout\_count.count**(count)                            | Number of timeout transactions.*Shown as transaction*                                                                                                                                                                                                    |

### Log collection{% #log-collection %}

1. The Pulsar log integration supports Pulsar's [default log format](https://pulsar.apache.org/docs/en/reference-configuration/#log4j). Clone and edit the [integration pipeline](https://docs.datadoghq.com/logs/processing/#integration-pipelines) if you have a different format.

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

   ```yaml
   logs_enabled: true
   ```

1. Uncomment and edit the logs configuration block in your `pulsar.d/conf.yaml` file. Change the path parameter value based on your environment. See the [sample pulsar.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/pulsar/datadog_checks/pulsar/data/conf.yaml.example) for all available configuration options.

   ```yaml
    logs:
      - type: file
        path: /pulsar/logs/pulsar.log
        source: pulsar
   ```

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

### Events{% #events %}

The Pulsar integration does not include any events.

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

**pulsar.openmetrics.health**

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

*Statuses: ok, critical*

## Troubleshooting{% #troubleshooting %}

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