---
title: CiscoACI
description: Track Cisco ACI performance and usage.
breadcrumbs: Docs > Integrations > CiscoACI
---

# CiscoACI
Supported OS Integration version4.14.1
## Overview{% #overview %}

[Network Device Monitoring](https://www.datadoghq.com/product/network-monitoring/#ndm) for Cisco ACI provides visibility into the health and performance of application-centric data center networks. By collecting metrics from Cisco ACI fabrics, controllers, and network devices, this integration helps teams monitor fabric health, track endpoint and interface behavior, and identify issues that may impact application connectivity within the data center. Datadog brings ACI network telemetry into a unified observability platform, enabling teams to correlate network behavior with application and infrastructure signals.

### Fabric and device health monitoring{% #fabric-and-device-health-monitoring %}

This integration surfaces key health indicators from ACI components, including device availability, resource utilization, and interface status. Teams can quickly identify failing nodes, degraded interfaces, or abnormal resource usage that may affect fabric stability.

### Interface and traffic analysis{% #interface-and-traffic-analysis %}

Cisco ACI environments handle large volumes of east-west and north-south traffic. Datadog tracks interface throughput, packet rates, errors, and utilization, helping teams detect congestion, packet loss, or misconfigurations that could impact application performance.

### Correlating network and application impact{% #correlating-network-and-application-impact %}

By integrating ACI metrics with Datadog's infrastructure and application monitoring, teams gain a clearer picture of how network issues propagate to application behavior. This end-to-end visibility helps reduce mean time to resolution when troubleshooting complex data center incidents.

**Minimum Agent version:** 6.3.2

## Setup{% #setup %}

**The Cisco ACI integration is Generally Available. To learn more about billing implications, visit our [pricing page](https://www.datadoghq.com/pricing/?product=network-monitoring&tab=network-device-monitoring#products).**

### Installation{% #installation %}

The Cisco ACI check is packaged with the Agent, so simply [install the Agent](https://app.datadoghq.com/account/settings/agent/latest) on a server within your network.

### Configuration{% #configuration %}

{% tab title="Host" %}
#### Host{% #host %}

To configure this check for an Agent running on a host:

1. Edit the `cisco_aci.d/conf.yaml` file, in the `conf.d/` folder at the root of your [Agent's configuration directory](https://docs.datadoghq.com/agent/guide/agent-configuration-files.md#agent-configuration-directory). See the [sample cisco_aci.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/cisco_aci/datadog_checks/cisco_aci/data/conf.yaml.example) for all available configuration options:

   ```yaml
   init_config:
   
   instances:
        ## @param aci_url - string - required
        ## URL to query to gather metrics.
        #
      - aci_url: http://localhost
   
        ## @param username - string - required
        ## Authentication can use either a user auth or a certificate.
        ## If using the user auth, enter the `username` and `pwd` configuration.
        #
        username: datadog
   
        ## @param pwd - string - required
        ## Authentication can use either a user auth or a certificate.
        ## If using the user auth, enter the `username` and `pwd` configuration.
        #
        pwd: <PWD>
   
        ## @param tenant - list of strings - optional
        ## List of tenants to collect metrics data from.
        #
        # tenant:
        #   - <TENANT_1>
        #   - <TENANT_2>
   
        ## @param send_ndm_metadata - boolean - optional - default: false
        ## Set to `true` to enable Network Device Monitoring metadata (for devices, interfaces, topology) to be sent
        ## and to allow Cisco ACI fault collection to be enabled.
        #
        # send_ndm_metadata: false
   
        #Enable collection of Cisco ACI fault logs (Requires send_ndm_metadata to be enabled).
   
        ## @param send_faultinst_faults - boolean - optional - default: false
        ## Set to `true` to enable collection of Cisco ACI faultInst faults as logs.
   
        # send_faultinst_faults: false
   
        ## @param send_faultdelegate_faults - boolean - optional - default: false
        ## Set to `true` to enable collection of Cisco ACI faultDelegate faults as logs.
   
        # send_faultdelegate_faults: false
   ```

1. If you have enabled `send_faultinst_faults` or `send_faultdelegate_faults`, ensure [logging is enabled](https://docs.datadoghq.com/logs/log_collection.md?tab=host#setup) in your Datadog `.yaml` file:

   ```yaml
   logs_enabled: true
   ```

1. Additionally, to receive ACI faults as logs, add the following configuration to the logs section of your `cisco_aci.d/conf.yaml` file:

   ```yaml
   logs:
     - type: integration
       source: cisco-aci
       service: cisco-aci
   ```

1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md#start-stop-and-restart-the-agent) to begin sending Cisco ACI metrics and optionally, ACI fault logs to Datadog.

**Note**: Be sure to specify any tenants for the integration to collect metrics on applications (for example, EPG).

{% /tab %}

{% tab title="Containerized" %}
#### Containerized{% #containerized %}

For containerized environments, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations.md) for guidance on applying the parameters below.

| Parameter            | Value                                                                  |
| -------------------- | ---------------------------------------------------------------------- |
| `<INTEGRATION_NAME>` | `cisco_aci`                                                            |
| `<INIT_CONFIG>`      | blank or `{}`                                                          |
| `<INSTANCE_CONFIG>`  | `{"aci_url":"%%host%%", "username":"<USERNAME>", "pwd": "<PASSWORD>"}` |

{% /tab %}

### Validation{% #validation %}

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

## Vendor profiles{% #vendor-profiles %}

Specific supported vendor profiles for this integration can be found on the [network vendors](https://docs.datadoghq.com/network_monitoring/devices/supported_devices.md) page.

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

### Metrics{% #metrics %}

|  |
|  |
| **cisco\_aci.capacity.apic.azure\_domain.endpoint\_group.limit**(gauge)  | the limit on the number of azure domain endpoint groups the apic can use*Shown as item*                                                                                                                                                                                                       |
| **cisco\_aci.capacity.apic.azure\_domain.limit**(gauge)                  | the limit on the number of azure domains the apic can use*Shown as item*                                                                                                                                                                                                                      |
| **cisco\_aci.capacity.apic.bridge\_domain.limit**(gauge)                 | the limit on the number of bridge domains the apic can use*Shown as item*                                                                                                                                                                                                                     |
| **cisco\_aci.capacity.apic.bridge\_domain.utilized**(gauge)              | the bridge domains the apic is utilizing*Shown as item*                                                                                                                                                                                                                                       |
| **cisco\_aci.capacity.apic.contract.limit**(gauge)                       | the limit on the number of contracts the apic can use*Shown as item*                                                                                                                                                                                                                          |
| **cisco\_aci.capacity.apic.endpoint.limit**(gauge)                       | the limit on the number of endpoints the apic can use*Shown as item*                                                                                                                                                                                                                          |
| **cisco\_aci.capacity.apic.endpoint.utilized**(gauge)                    | the endpoints the apic is utilizing*Shown as item*                                                                                                                                                                                                                                            |
| **cisco\_aci.capacity.apic.endpoint\_group.limit**(gauge)                | the limit on the number of endpoint groups the apic can use*Shown as item*                                                                                                                                                                                                                    |
| **cisco\_aci.capacity.apic.endpoint\_group.utilized**(gauge)             | the endpoint groups the apic is utilizing*Shown as item*                                                                                                                                                                                                                                      |
| **cisco\_aci.capacity.apic.fabric\_node.limit**(gauge)                   | the limit on the number of fabric nodes the apic can use*Shown as item*                                                                                                                                                                                                                       |
| **cisco\_aci.capacity.apic.fabric\_node.utilized**(gauge)                | the number of fabric nodes the apic is using*Shown as item*                                                                                                                                                                                                                                   |
| **cisco\_aci.capacity.apic.private\_network.limit**(gauge)               | the limit on the number of fabric nodes the apic can use*Shown as item*                                                                                                                                                                                                                       |
| **cisco\_aci.capacity.apic.private\_network.utilized**(gauge)            | the number of private networks the apic is using*Shown as item*                                                                                                                                                                                                                               |
| **cisco\_aci.capacity.apic.service\_graph.limit**(gauge)                 | the limit on the number of service graphs the apic can use*Shown as item*                                                                                                                                                                                                                     |
| **cisco\_aci.capacity.apic.tenant.limit**(gauge)                         | the limit on the number of tenants the apic can use*Shown as item*                                                                                                                                                                                                                            |
| **cisco\_aci.capacity.apic.tenant.utilized**(gauge)                      | the number of tenants the apic is using*Shown as item*                                                                                                                                                                                                                                        |
| **cisco\_aci.capacity.apic.vmware\_domain.endpoint\_group.limit**(gauge) | the limit on the number of azure domain endpoint groups the apic can use*Shown as item*                                                                                                                                                                                                       |
| **cisco\_aci.capacity.apic.vmware\_domain.limit**(gauge)                 | the limit on number of vmware domains the apic can use*Shown as item*                                                                                                                                                                                                                         |
| **cisco\_aci.capacity.leaf.bridge\_domain.limit**(gauge)                 | the limit on the number of bridge domains the leaf can use*Shown as item*                                                                                                                                                                                                                     |
| **cisco\_aci.capacity.leaf.bridge\_domain.utilized**(gauge)              | the number of bridge domains the leaf is using*Shown as item*                                                                                                                                                                                                                                 |
| **cisco\_aci.capacity.leaf.endpoint\_group.limit**(gauge)                | the limit on number of endpoint groups the leaf can use*Shown as item*                                                                                                                                                                                                                        |
| **cisco\_aci.capacity.leaf.endpoint\_group.utilized**(gauge)             | the number of endpoint groups the leaf is using*Shown as item*                                                                                                                                                                                                                                |
| **cisco\_aci.capacity.leaf.ipv4\_endpoint.limit**(gauge)                 | the limit on the number of ipv4 addresses for the leaf. Requires version 3.1+*Shown as item*                                                                                                                                                                                                  |
| **cisco\_aci.capacity.leaf.ipv4\_endpoint.utilized**(gauge)              | the number of ipv4 addresses the leaf is utilizing. Requires version 3.1+*Shown as item*                                                                                                                                                                                                      |
| **cisco\_aci.capacity.leaf.ipv6\_endpoint.limit**(gauge)                 | the limit on the number of ipv6 addresses for the leaf. Requires version 3.1+*Shown as item*                                                                                                                                                                                                  |
| **cisco\_aci.capacity.leaf.ipv6\_endpoint.utilized**(gauge)              | the number of ipv6 addresses the leaf is utilizing. Requires version 3.1+*Shown as item*                                                                                                                                                                                                      |
| **cisco\_aci.capacity.leaf.multicast.limit**(gauge)                      | the multicast endpoint capacity of the leaf*Shown as item*                                                                                                                                                                                                                                    |
| **cisco\_aci.capacity.leaf.multicast.utilized**(gauge)                   | the multicast endpoint capacity utilized by the leaf*Shown as item*                                                                                                                                                                                                                           |
| **cisco\_aci.capacity.leaf.policy\_cam.limit**(gauge)                    | the limit on the number of policies in the policy cam*Shown as item*                                                                                                                                                                                                                          |
| **cisco\_aci.capacity.leaf.policy\_cam.utilized**(gauge)                 | the number of policies the policy cam is utilizing*Shown as item*                                                                                                                                                                                                                             |
| **cisco\_aci.capacity.leaf.vlan.limit**(gauge)                           | the limit on the number of vlans for the leaf*Shown as item*                                                                                                                                                                                                                                  |
| **cisco\_aci.capacity.leaf.vlan.utilized**(gauge)                        | the number of vlan the leaf is utilizing*Shown as item*                                                                                                                                                                                                                                       |
| **cisco\_aci.capacity.leaf.vrf.limit**(gauge)                            | the limit on the number of vrfs the leaf can use*Shown as item*                                                                                                                                                                                                                               |
| **cisco\_aci.capacity.leaf.vrf.utilized**(gauge)                         | the number of vrfs the leaf is using*Shown as item*                                                                                                                                                                                                                                           |
| **cisco\_aci.fabric.node.cpu.avg**(gauge)                                | average cpu usage of the node*Shown as percent*                                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.node.cpu.idle.avg**(gauge)                           | average idle cpu of the node*Shown as percent*                                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.node.cpu.idle.max**(gauge)                           | max idle cpu of the node*Shown as percent*                                                                                                                                                                                                                                                    |
| **cisco\_aci.fabric.node.cpu.idle.min**(gauge)                           | minimum idle cpu of the node*Shown as percent*                                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.node.cpu.max**(gauge)                                | max cpu usage of the node*Shown as percent*                                                                                                                                                                                                                                                   |
| **cisco\_aci.fabric.node.cpu.min**(gauge)                                | minimum cpu usage of the node*Shown as percent*                                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.node.egr\_bytes.flood**(gauge)                       | Egress flood packets*Shown as byte*                                                                                                                                                                                                                                                           |
| **cisco\_aci.fabric.node.egr\_bytes.flood.cum**(gauge)                   | the cumulative flood packets sent from the node*Shown as byte*                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.node.egr\_bytes.multicast**(gauge)                   | the number of multicast bytes coming from the node*Shown as byte*                                                                                                                                                                                                                             |
| **cisco\_aci.fabric.node.egr\_bytes.multicast.cum**(gauge)               | the cumulative multicast bytes sent from the node*Shown as byte*                                                                                                                                                                                                                              |
| **cisco\_aci.fabric.node.egr\_bytes.unicast**(gauge)                     | the number of unicast bytes coming from the node*Shown as byte*                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.node.egr\_bytes.unicast.cum**(gauge)                 | the cumulative bytes sent from the node*Shown as byte*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.node.egr\_drop\_pkts.buffer**(gauge)                 | the packets dropped because the buffer is full*Shown as packet*                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.node.egr\_drop\_pkts.buffer.cum**(gauge)             | the cumulative packets dropped because the buffer is full*Shown as packet*                                                                                                                                                                                                                    |
| **cisco\_aci.fabric.node.egr\_drop\_pkts.errors**(gauge)                 | the packets dropped because of errors*Shown as packet*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.node.egr\_total.bytes.cum**(gauge)                   | the cumulative bytes sent from the node*Shown as byte*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.node.egr\_total.bytes.rate**(gauge)                  | the bytes per second sent from the node*Shown as byte*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.node.egr\_total.pkts**(gauge)                        | the packets sent from the node*Shown as packet*                                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.node.egr\_total.pkts.rate**(gauge)                   | the packets per second sent from the node*Shown as packet*                                                                                                                                                                                                                                    |
| **cisco\_aci.fabric.node.fault\_counter.crit**(gauge)                    | the number of critical faults on the node*Shown as fault*                                                                                                                                                                                                                                     |
| **cisco\_aci.fabric.node.fault\_counter.warn**(gauge)                    | the number of warnings on the node*Shown as fault*                                                                                                                                                                                                                                            |
| **cisco\_aci.fabric.node.health.cur**(gauge)                             | the current health of the node                                                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.node.health.max**(gauge)                             | The max health of the node                                                                                                                                                                                                                                                                    |
| **cisco\_aci.fabric.node.health.min**(gauge)                             | the minimum health of the node                                                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.node.ingr\_bytes.flood**(gauge)                      | Ingress flood packets*Shown as byte*                                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.node.ingr\_bytes.flood.cum**(gauge)                  | the cumulative flood packets sent to the node*Shown as byte*                                                                                                                                                                                                                                  |
| **cisco\_aci.fabric.node.ingr\_bytes.multicast**(gauge)                  | the number of multicast bytes coming into the node*Shown as byte*                                                                                                                                                                                                                             |
| **cisco\_aci.fabric.node.ingr\_bytes.multicast.cum**(gauge)              | the cumulative multicast bytes sent to the node*Shown as byte*                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.node.ingr\_bytes.unicast**(gauge)                    | the number of unicast bytes coming into the node*Shown as byte*                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.node.ingr\_bytes.unicast.cum**(gauge)                | the cumulative bytes sent to the node*Shown as byte*                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.node.ingr\_total.bytes.cum**(gauge)                  | the cumulative bytes sent to the node*Shown as byte*                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.node.ingr\_total.bytes.rate**(gauge)                 | the bytes per second sent to the node*Shown as byte*                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.node.ingr\_total.pkts**(gauge)                       | the packets sent to the node*Shown as packet*                                                                                                                                                                                                                                                 |
| **cisco\_aci.fabric.node.ingr\_total.pkts.rate**(gauge)                  | the packets per second sent to the node*Shown as packet*                                                                                                                                                                                                                                      |
| **cisco\_aci.fabric.node.mem.avg**(gauge)                                | average memory usage of the node*Shown as byte*                                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.node.mem.free.avg**(gauge)                           | average free memory of the node*Shown as byte*                                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.node.mem.free.max**(gauge)                           | max free memory of the node*Shown as byte*                                                                                                                                                                                                                                                    |
| **cisco\_aci.fabric.node.mem.free.min**(gauge)                           | minimum free memory of the node*Shown as byte*                                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.node.mem.max**(gauge)                                | max memory usage of the node*Shown as byte*                                                                                                                                                                                                                                                   |
| **cisco\_aci.fabric.node.mem.min**(gauge)                                | minimum memory usage of the node*Shown as byte*                                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.pod.egr\_bytes.flood**(gauge)                        | Egress flood packets*Shown as byte*                                                                                                                                                                                                                                                           |
| **cisco\_aci.fabric.pod.egr\_bytes.flood.cum**(gauge)                    | the cumulative flood packets sent from the pod*Shown as byte*                                                                                                                                                                                                                                 |
| **cisco\_aci.fabric.pod.egr\_bytes.multicast**(gauge)                    | the number of multicast bytes coming from the pod*Shown as byte*                                                                                                                                                                                                                              |
| **cisco\_aci.fabric.pod.egr\_bytes.multicast.cum**(gauge)                | the cumulative multicast bytes sent from the pod*Shown as byte*                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.pod.egr\_bytes.unicast**(gauge)                      | the number of unicast bytes coming from the pod*Shown as byte*                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.pod.egr\_bytes.unicast.cum**(gauge)                  | the cumulative bytes sent from the pod*Shown as byte*                                                                                                                                                                                                                                         |
| **cisco\_aci.fabric.pod.egr\_drop\_pkts.buffer**(gauge)                  | the packets dropped because the buffer is full*Shown as packet*                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.pod.egr\_drop\_pkts.buffer.cum**(gauge)              | the cumulative packets dropped because the buffer is full*Shown as packet*                                                                                                                                                                                                                    |
| **cisco\_aci.fabric.pod.egr\_drop\_pkts.errors**(gauge)                  | the packets dropped because of errors*Shown as packet*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.pod.egr\_total.bytes.cum**(gauge)                    | the cumulative bytes sent from the pod*Shown as byte*                                                                                                                                                                                                                                         |
| **cisco\_aci.fabric.pod.egr\_total.bytes.rate**(gauge)                   | the bytes per second sent from the pod*Shown as byte*                                                                                                                                                                                                                                         |
| **cisco\_aci.fabric.pod.egr\_total.pkts**(gauge)                         | the packets sent from the pod*Shown as packet*                                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.pod.egr\_total.pkts.rate**(gauge)                    | the packets per second sent from the pod*Shown as packet*                                                                                                                                                                                                                                     |
| **cisco\_aci.fabric.pod.fault\_counter.crit**(gauge)                     | the number of critical faults on the pod*Shown as fault*                                                                                                                                                                                                                                      |
| **cisco\_aci.fabric.pod.fault\_counter.warn**(gauge)                     | the number of warnings on the pod*Shown as fault*                                                                                                                                                                                                                                             |
| **cisco\_aci.fabric.pod.health.cur**(gauge)                              | the current health of the pod                                                                                                                                                                                                                                                                 |
| **cisco\_aci.fabric.pod.health.max**(gauge)                              | the maximum health of the pod                                                                                                                                                                                                                                                                 |
| **cisco\_aci.fabric.pod.health.min**(gauge)                              | the minimum health of the pod                                                                                                                                                                                                                                                                 |
| **cisco\_aci.fabric.pod.ingr\_bytes.flood**(gauge)                       | Ingress flood packets*Shown as byte*                                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.pod.ingr\_bytes.flood.cum**(gauge)                   | the cumulative flood packets sent to the pod*Shown as byte*                                                                                                                                                                                                                                   |
| **cisco\_aci.fabric.pod.ingr\_bytes.multicast**(gauge)                   | the number of multicast bytes coming into the pod*Shown as byte*                                                                                                                                                                                                                              |
| **cisco\_aci.fabric.pod.ingr\_bytes.multicast.cum**(gauge)               | the cumulative multicast bytes sent to the pod*Shown as byte*                                                                                                                                                                                                                                 |
| **cisco\_aci.fabric.pod.ingr\_bytes.unicast**(gauge)                     | the number of unicast bytes coming into the pod*Shown as byte*                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.pod.ingr\_bytes.unicast.cum**(gauge)                 | the cumulative bytes sent to the pod*Shown as byte*                                                                                                                                                                                                                                           |
| **cisco\_aci.fabric.pod.ingr\_total.bytes.cum**(gauge)                   | the cumulative bytes sent to the pod*Shown as byte*                                                                                                                                                                                                                                           |
| **cisco\_aci.fabric.pod.ingr\_total.bytes.rate**(gauge)                  | the bytes per second sent to the pod*Shown as byte*                                                                                                                                                                                                                                           |
| **cisco\_aci.fabric.pod.ingr\_total.pkts**(gauge)                        | the packets sent to the pod*Shown as packet*                                                                                                                                                                                                                                                  |
| **cisco\_aci.fabric.pod.ingr\_total.pkts.rate**(gauge)                   | the packets per second sent to the pod*Shown as packet*                                                                                                                                                                                                                                       |
| **cisco\_aci.fabric.port.egr\_bytes.flood**(gauge)                       | Egress flood packets*Shown as byte*                                                                                                                                                                                                                                                           |
| **cisco\_aci.fabric.port.egr\_bytes.flood.cum**(gauge)                   | the cumulative flood packets sent from the port*Shown as byte*                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.port.egr\_bytes.multicast**(gauge)                   | the number of multicast bytes coming from the port*Shown as byte*                                                                                                                                                                                                                             |
| **cisco\_aci.fabric.port.egr\_bytes.multicast.cum**(gauge)               | the cumulative multicast bytes sent from the port*Shown as byte*                                                                                                                                                                                                                              |
| **cisco\_aci.fabric.port.egr\_bytes.unicast**(gauge)                     | the number of unicast bytes coming from the port*Shown as byte*                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.port.egr\_bytes.unicast.cum**(gauge)                 | the cumulative bytes sent from the port*Shown as byte*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.port.egr\_drop\_pkts.buffer**(gauge)                 | the packets dropped because the buffer is full*Shown as packet*                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.port.egr\_drop\_pkts.buffer.cum**(gauge)             | the cumulative packets dropped because the buffer is full*Shown as packet*                                                                                                                                                                                                                    |
| **cisco\_aci.fabric.port.egr\_drop\_pkts.errors**(gauge)                 | the packets dropped because of errors*Shown as packet*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.port.egr\_total.bytes.cum**(gauge)                   | the cumulative bytes sent from the port*Shown as byte*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.port.egr\_total.bytes.rate**(gauge)                  | the bytes per second sent from the port*Shown as byte*                                                                                                                                                                                                                                        |
| **cisco\_aci.fabric.port.egr\_total.pkts**(gauge)                        | the packets sent from the port*Shown as packet*                                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.port.egr\_total.pkts.rate**(gauge)                   | the packets per second sent from the port*Shown as packet*                                                                                                                                                                                                                                    |
| **cisco\_aci.fabric.port.fault\_counter.crit**(gauge)                    | the number of critical faults on the port*Shown as fault*                                                                                                                                                                                                                                     |
| **cisco\_aci.fabric.port.fault\_counter.warn**(gauge)                    | the number of warnings on the port*Shown as fault*                                                                                                                                                                                                                                            |
| **cisco\_aci.fabric.port.ingr\_bytes.flood**(gauge)                      | Ingress flood packets*Shown as byte*                                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.port.ingr\_bytes.flood.cum**(gauge)                  | the cumulative flood packets sent to the port*Shown as byte*                                                                                                                                                                                                                                  |
| **cisco\_aci.fabric.port.ingr\_bytes.multicast**(gauge)                  | the number of multicast bytes coming into the port*Shown as byte*                                                                                                                                                                                                                             |
| **cisco\_aci.fabric.port.ingr\_bytes.multicast.cum**(gauge)              | the cumulative multicast bytes sent to the port*Shown as byte*                                                                                                                                                                                                                                |
| **cisco\_aci.fabric.port.ingr\_bytes.unicast**(gauge)                    | the number of unicast bytes coming into the port*Shown as byte*                                                                                                                                                                                                                               |
| **cisco\_aci.fabric.port.ingr\_bytes.unicast.cum**(gauge)                | the cumulative bytes sent to the port*Shown as byte*                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.port.ingr\_total.bytes.cum**(gauge)                  | the cumulative bytes sent to the port*Shown as byte*                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.port.ingr\_total.bytes.rate**(gauge)                 | the bytes per second sent to the port*Shown as byte*                                                                                                                                                                                                                                          |
| **cisco\_aci.fabric.port.ingr\_total.pkts**(gauge)                       | the packets sent to the port*Shown as packet*                                                                                                                                                                                                                                                 |
| **cisco\_aci.fabric.port.ingr\_total.pkts.rate**(gauge)                  | the packets per second sent to the port*Shown as packet*                                                                                                                                                                                                                                      |
| **cisco\_aci.fabric.port.status**(gauge)                                 | For each interface of each monitored Cisco ACI device, this metric reports always 1 with the status a tag, as long as a 'combined' status that can be used for monitors.                                                                                                                      |
| **cisco\_aci.tenant.application.endpoint.fault\_counter**(gauge)         | represents the warning Fault. This is the average value read by the counter during the collection interval. Note that this value resets to 0 at the beginning of each interval*Shown as fault*                                                                                                |
| **cisco\_aci.tenant.application.endpoint.health**(gauge)                 | represents the most current statistics for the endpoint health*Shown as percent*                                                                                                                                                                                                              |
| **cisco\_aci.tenant.application.endpoint.overall\_health**(gauge)        | represents the statistics for the overall endpoint health*Shown as percent*                                                                                                                                                                                                                   |
| **cisco\_aci.tenant.application.fault\_counter**(gauge)                  | represents the warning Fault. This is the average value read by the counter during the collection interval. Note that this value resets to 0 at the beginning of each interval*Shown as fault*                                                                                                |
| **cisco\_aci.tenant.application.health**(gauge)                          | represents the most current statistics for the application health*Shown as percent*                                                                                                                                                                                                           |
| **cisco\_aci.tenant.application.overall\_health**(gauge)                 | represents the statistics for the overall application health*Shown as percent*                                                                                                                                                                                                                |
| **cisco\_aci.tenant.egress\_bytes.drop.cum**(gauge)                      | represents the Egress drop bytes. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as byte*                                                                                                                             |
| **cisco\_aci.tenant.egress\_bytes.flood.cum**(gauge)                     | represents the Egress flood bytes. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as byte*                                                                                                                            |
| **cisco\_aci.tenant.egress\_bytes.multicast.cum**(gauge)                 | represents the sum total of values read by the multicast counter. Note that this value continues through each interval without resetting to zero*Shown as byte*                                                                                                                               |
| **cisco\_aci.tenant.egress\_bytes.multicast.rate**(gauge)                | represents the rate of the egress multicast counter readings in an interval. The rate is calculated by dividing the periodic value by the length of the interval. This value resets to 0 at the beginning of each interval*Shown as byte*                                                     |
| **cisco\_aci.tenant.egress\_bytes.unicast.cum**(gauge)                   | represents the sum total of values read by the unicast counter. Note that this value continues through each interval without resetting to zero*Shown as byte*                                                                                                                                 |
| **cisco\_aci.tenant.egress\_bytes.unicast.rate**(gauge)                  | represents the rate of the egress unicast counter readings in an interval. The rate is calculated by dividing the periodic value by the length of the interval. This value resets to 0 at the beginning of each interval*Shown as byte*                                                       |
| **cisco\_aci.tenant.egress\_pkts.drop.cum**(gauge)                       | represents the Egress drop packets. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as packet*                                                                                                                         |
| **cisco\_aci.tenant.egress\_pkts.flood.cum**(gauge)                      | represents the Egress flood packets. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as packet*                                                                                                                        |
| **cisco\_aci.tenant.egress\_pkts.multicast.cum**(gauge)                  | represents the sum total of values read by the multicast counter. Note that this value continues through each interval without resetting to zero.*Shown as packet*                                                                                                                            |
| **cisco\_aci.tenant.egress\_pkts.multicast.rate**(gauge)                 | represents the rate of the ingress multicast counter readings in an interval. The rate is calculated by dividing the periodic value by the length of the interval. This value resets to 0 at the beginning of each interval*Shown as packet*                                                  |
| **cisco\_aci.tenant.egress\_pkts.unicast.cum**(gauge)                    | represents the sum total of values read by the unicast counter. Note that this value continues through each interval without resetting to zero*Shown as packet*                                                                                                                               |
| **cisco\_aci.tenant.egress\_pkts.unicast.rate**(gauge)                   | represents the rate of the ingress unicast counter readings in an interval. The rate is calculated by dividing the periodic value by the length of the interval. This value resets to 0 at the beginning of each interval*Shown as packet*                                                    |
| **cisco\_aci.tenant.fault\_counter**(gauge)                              | represents the warning Fault. This is the average value read by the counter during the collection interval. Note that this value resets to 0 at the beginning of each interval*Shown as fault*                                                                                                |
| **cisco\_aci.tenant.health**(gauge)                                      | represents the most current statistics for the tenant health*Shown as percent*                                                                                                                                                                                                                |
| **cisco\_aci.tenant.ingress\_bytes.drop.cum**(gauge)                     | represents the Ingress drop bytes. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as byte*                                                                                                                            |
| **cisco\_aci.tenant.ingress\_bytes.flood.cum**(gauge)                    | represents the Ingress flood bytes. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as byte*                                                                                                                           |
| **cisco\_aci.tenant.ingress\_bytes.multicast.cum**(gauge)                | represents the Ingress multicast bytes. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as byte*                                                                                                                       |
| **cisco\_aci.tenant.ingress\_bytes.multicast.rate**(gauge)               | represents the Ingress multicast bytes. This is the rate of the counter during the collection interval. The rate is calculated by dividing the periodic value by the length of the collection interval. Note that this value resets to 0 at the beginning of each interval.*Shown as byte*    |
| **cisco\_aci.tenant.ingress\_bytes.unicast.cum**(gauge)                  | represents the Ingress unicast bytes. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as byte*                                                                                                                         |
| **cisco\_aci.tenant.ingress\_bytes.unicast.rate**(gauge)                 | represents the Ingress unicast bytes. This is the rate of the counter during the collection interval. The rate is calculated by dividing the periodic value by the length of the collection interval. Note that this value resets to 0 at the beginning of each interval*Shown as byte*       |
| **cisco\_aci.tenant.ingress\_pkts.drop.cum**(gauge)                      | represents the Ingress drop packets. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as packet*                                                                                                                        |
| **cisco\_aci.tenant.ingress\_pkts.flood.cum**(gauge)                     | represents the Ingress flood packets. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as packet*                                                                                                                       |
| **cisco\_aci.tenant.ingress\_pkts.multicast.cum**(gauge)                 | represents the Ingress multicast packets. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as packet*                                                                                                                   |
| **cisco\_aci.tenant.ingress\_pkts.multicast.rate**(gauge)                | represents the Ingress multicast packets. This is the rate of the counter during the collection interval. The rate is calculated by dividing the periodic value by the length of the collection interval. Note that this value resets to 0 at the beginning of each interval*Shown as packet* |
| **cisco\_aci.tenant.ingress\_pkts.unicast.cum**(gauge)                   | represents the Ingress unicast packets. The total sum of the values read. Note that this value continues through each interval without resetting to zero*Shown as packet*                                                                                                                     |
| **cisco\_aci.tenant.ingress\_pkts.unicast.rate**(gauge)                  | represents the Ingress unicast packets. This is the rate of the counter during the collection interval. The rate is calculated by dividing the periodic value by the length of the collection interval. Note that this value resets to 0 at the beginning of each interval*Shown as packet*   |
| **cisco\_aci.tenant.overall\_health**(gauge)                             | represents the statistics for overall tenant health*Shown as percent*                                                                                                                                                                                                                         |

### Cisco ACI faults{% #cisco-aci-faults %}

**Note**: Requires `send_ndm_metadata` to be enabled.

Cisco ACI faults are collected by the Agent and stored in Datadog as logs. They can be viewed from the [Cisco ACI dashboard](https://app.datadoghq.com/dash/integration/242/cisco-aci---overview), or by filtering for `source:cisco-aci` in the [Log Explorer](https://app.datadoghq.com/logs).

There are two types of Cisco ACI faults: `fault:Inst` and `fault:Delegate`. See [fault objects and records](https://www.cisco.com/c/en/us/td/docs/switches/datacenter/aci/apic/sw/all/faults/guide/b_APIC_Faults_Errors/b_IFC_Faults_Errors_chapter_01.html) for more information.

The Cisco ACI config `.yaml` file can be set up to collect one or both of the following fault types:

| Fault Type                                                                                                                                                                 | Description                                                                     |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| [send_faultinst_faults](https://github.com/DataDog/integrations-core/blob/c5890c7b6946a5e7e9d4c6eda993821eb6b75055/cisco_aci/assets/configuration/spec.yaml#L109-L115)     | Set to `true` to enable collection of Cisco ACI `faultInst` faults as logs.     |
| [send_faultdelegate_faults](https://github.com/DataDog/integrations-core/blob/c5890c7b6946a5e7e9d4c6eda993821eb6b75055/cisco_aci/assets/configuration/spec.yaml#L116-L122) | Set to `true` to enable collection of Cisco ACI `faultDelegate` faults as logs. |

### Events{% #events %}

The Cisco ACI check sends tenant faults as events.

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

**cisco\_aci.can\_connect**

Returns `CRITICAL` if the Agent check is unable to connect to the monitored cisco_aci instance. Returns `OK` otherwise.

*Statuses: ok, critical*

## Troubleshooting{% #troubleshooting %}

### Missing `cisco_aci.tenant.*` metrics{% #missing-cisco_acitenant-metrics %}

If you are missing `cisco_aci.tenant.*` metrics, you can run the `tests/cisco_aci_query.py` [script](https://github.com/DataDog/integrations-core/blob/master/cisco_aci/tests/cisco_aci_query.py) to manually query the tenant endpoint.

Modify the `apic_url`, `apic_username`, and `apic_password` to your configuration information, and input the tenant URL for the `apic_url`.

Verify that the output you get from cURLing the endpoint matches any of the metrics collected in `datadog_checks/cisco_aci/aci_metrics.py`. If none of the statistics match, this means that the endpoint is not emitting any statistics that the integration can collect.

### Long execution times{% #long-execution-times %}

Because this check queries all the tenants, apps, and endpoints listed before returning metrics, there may be high execution times coming from this integration.

```yaml
  cisco_aci (2.2.0)
-----------------
  Instance ID: cisco_aci:d3a2958f66f46212 [OK]
  Configuration Source: file:/etc/datadog-agent/conf.d/cisco_aci.d/conf.yaml
  Total Runs: 1
  Metric Samples: Last Run: 678, Total: 678
  Events: Last Run: 0, Total: 0
  Service Checks: Last Run: 1, Total: 1
  Average Execution Time : 28m20.95s
  Last Execution Date : 2023-01-04 15:58:04 CST / 2023-01-04 21:58:04 UTC (1672869484000)
  Last Successful Execution Date : 2023-01-04 15:58:04 CST / 2023-01-04 21:58:04 UTC (1672869484000)
```

### Help{% #help %}

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