---
title: Wayfinder
description: Send Wayfinder metrics to Datadog
breadcrumbs: Docs > Integrations > Wayfinder
---

# Wayfinder
Supported OS Integration version1.0.1  Wayfinder Sample Datadog DashboardWayfinder UI
## Overview{% #overview %}

[Wayfinder](https://www.appvia.io/product/) is an infrastructure management platform that enables developer self-service through a centralized configuration. This check monitors Wayfinder key management components through the Datadog Agent.

The integration collects key metrics from the Wayfinder API server, controller, and webhook components. These metrics should highlight issues in managed workspaces.

## Setup{% #setup %}

Follow the instructions below to install the integration in the Wayfinder Kubernetes management cluster.

### Installation{% #installation %}

For containerized environments, the best way to use this integration with the Docker Agent is to build the Agent with the Wayfinder integration installed.

### Prerequisites:{% #prerequisites %}

A network policy must be configured to allow the Datadog Agent to connect to Wayfinder components. The network policy below assumes Datadog is deployed to the Datadog namespace and Wayfinder is deployed to the Wayfinder namespace.

```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: datadog-agent
  namespace: wayfinder
spec:
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: datadog
      podSelector:
        matchLabels:
          app: datadog-agent
    ports:
    - port: 9090
      protocol: TCP
  podSelector:
    matchExpressions:
    - key: name
      operator: In
      values:
      - wayfinder-controllers
      - wayfinder-apiserver
      - wayfinder-webhooks
  policyTypes:
  - Ingress
```

To build an updated version of the Agent:

1. Use the following Dockerfile:

   ```dockerfile
   FROM gcr.io/datadoghq/agent:latest
   
   ARG INTEGRATION_VERSION=1.0.0
   
   RUN agent integration install -r -t datadog-wayfinder==${INTEGRATION_VERSION}
   ```

1. Build the image and push it to your private Docker registry.

1. Upgrade the Datadog Agent container image. If you are using a Helm chart, modify the `agents.image` section in the `values.yaml` file to replace the default agent image:

   ```yaml
   agents:
     enabled: true
     image:
       tag: <NEW_TAG>
       repository: <YOUR_PRIVATE_REPOSITORY>/<AGENT_NAME>
   ```

1. Use the new `values.yaml` file to upgrade the Agent:

   ```shell
   helm upgrade -f values.yaml <RELEASE_NAME> datadog/datadog
   ```

### Configuration{% #configuration %}

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

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

### Metrics{% #metrics %}

|  |
|  |
| **wayfinder.controller\_runtime.active\_workers**(gauge)                 | Number of currently used workers per controller.                                                                                                                                                                                     |
| **wayfinder.controller\_runtime.max\_concurrent\_reconciles**(gauge)     | Maximum number of concurrent reconciles per controller.                                                                                                                                                                              |
| **wayfinder.controller\_runtime.reconcile\_errors\_total.count**(count)  | Total number of reconciliation errors per controller.                                                                                                                                                                                |
| **wayfinder.controller\_runtime.reconcile\_time\_seconds.bucket**(count) | Bucket of length of time per reconciliation per controller.                                                                                                                                                                          |
| **wayfinder.controller\_runtime.reconcile\_time\_seconds.count**(count)  | Count of length of time per reconciliation per controller.                                                                                                                                                                           |
| **wayfinder.controller\_runtime.reconcile\_time\_seconds.sum**(count)    | Sum of length of time per reconciliation per controller.                                                                                                                                                                             |
| **wayfinder.controller\_runtime.reconcile\_total.count**(count)          | A summary of the total controller reconciles.                                                                                                                                                                                        |
| **wayfinder.workqueue.adds\_total.count**(count)                         | Total number of adds handled by workqueue.                                                                                                                                                                                           |
| **wayfinder.workqueue.depth**(gauge)                                     | Current depth of workqueue.                                                                                                                                                                                                          |
| **wayfinder.workqueue.queue\_duration\_seconds.bucket**(count)           | Bucket of length of time in seconds an item stays in workqueue before being requested.                                                                                                                                               |
| **wayfinder.workqueue.queue\_duration\_seconds.count**(count)            | Count of time in seconds an item stays in workqueue before being requested.                                                                                                                                                          |
| **wayfinder.workqueue.queue\_duration\_seconds.sum**(count)              | Sum of time in seconds an item stays in workqueue before being requested.                                                                                                                                                            |
| **wayfinder.workqueue.retries.count**(count)                             | Total number of retries handled by workqueue.                                                                                                                                                                                        |
| **wayfinder.workqueue.unfinished\_work\_seconds**(gauge)                 | How many seconds of work has been done that is in progress and hasn't been observed by work_duration. Large values indicate stuck threads. One can deduce the number of stuck threads by observing the rate at which this increases. |

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

Wayfinder does not include any service checks.

### Events{% #events %}

Wayfinder does not include any events.

## Troubleshooting{% #troubleshooting %}

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