---
title: Tekton
description: Track all your Tekton metrics with Datadog.
breadcrumbs: Docs > Integrations > Tekton
---

# Tekton
Supported OS Integration version3.3.0
## Overview{% #overview %}

This check monitors [Tekton](https://tekton.dev/) through the Datadog Agent. Tekton is a powerful and flexible open source framework for creating CI/CD systems, allowing developers to build, test, and deploy across cloud providers and on-premise systems.

**Minimum Agent version:** 7.53.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 %}

Starting from Agent release 7.53.0, the Tekton check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed on your server.

This check uses [OpenMetrics](https://docs.datadoghq.com/integrations/openmetrics/) to collect metrics from the OpenMetrics endpoint that Tekton exposes, which requires Python 3.

### Configuration{% #configuration %}

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

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

### Metrics{% #metrics %}

|  |
|  |
| **tekton.pipelines\_controller.client.latency.bucket**(count)                                    | Duration of Kubernetes API requests.                                                                            |
| **tekton.pipelines\_controller.client.latency.count**(count)                                     | Duration of Kubernetes API requests.                                                                            |
| **tekton.pipelines\_controller.client.latency.sum**(count)                                       | Duration of Kubernetes API requests.*Shown as second*                                                           |
| **tekton.pipelines\_controller.client.results.count**(count)                                     | Total number of API requests (broken down by status code).*Shown as request*                                    |
| **tekton.pipelines\_controller.go.alloc**(gauge)                                                 | The number of bytes of allocated heap objects.*Shown as byte*                                                   |
| **tekton.pipelines\_controller.go.bucket\_hash\_sys**(gauge)                                     | The number of bytes of memory in profiling bucket hash tables.*Shown as byte*                                   |
| **tekton.pipelines\_controller.go.frees**(gauge)                                                 | The number of heap objects freed.*Shown as object*                                                              |
| **tekton.pipelines\_controller.go.gc\_cpu\_fraction**(gauge)                                     | The fraction of this program's available CPU time used by the GC since the program started.*Shown as fraction*  |
| **tekton.pipelines\_controller.go.gc\_sys**(gauge)                                               | The number of bytes of memory in garbage collection metadata.*Shown as byte*                                    |
| **tekton.pipelines\_controller.go.heap\_alloc**(gauge)                                           | The number of bytes of allocated heap objects.*Shown as byte*                                                   |
| **tekton.pipelines\_controller.go.heap\_idle**(gauge)                                            | The number of bytes in idle (unused) spans.*Shown as byte*                                                      |
| **tekton.pipelines\_controller.go.heap\_in\_use**(gauge)                                         | The number of bytes in in-use spans.*Shown as byte*                                                             |
| **tekton.pipelines\_controller.go.heap\_objects**(gauge)                                         | The number of allocated heap objects.*Shown as object*                                                          |
| **tekton.pipelines\_controller.go.heap\_released**(gauge)                                        | The number of bytes of physical memory returned to the OS.*Shown as byte*                                       |
| **tekton.pipelines\_controller.go.heap\_sys**(gauge)                                             | The number of bytes of heap memory obtained from the OS.*Shown as byte*                                         |
| **tekton.pipelines\_controller.go.last\_gc**(gauge)                                              | The time the last garbage collection finished, as nanoseconds since 1970 (the UNIX epoch).*Shown as nanosecond* |
| **tekton.pipelines\_controller.go.lookups**(gauge)                                               | The number of pointer lookups performed by the runtime.*Shown as operation*                                     |
| **tekton.pipelines\_controller.go.mallocs**(gauge)                                               | The number of heap objects allocated.*Shown as object*                                                          |
| **tekton.pipelines\_controller.go.mcache\_in\_use**(gauge)                                       | The number of bytes of allocated mcache structures.*Shown as byte*                                              |
| **tekton.pipelines\_controller.go.mcache\_sys**(gauge)                                           | The number of bytes of memory obtained from the OS for mcache structures.*Shown as byte*                        |
| **tekton.pipelines\_controller.go.mspan\_in\_use**(gauge)                                        | The number of bytes of allocated mspan structures.*Shown as byte*                                               |
| **tekton.pipelines\_controller.go.mspan\_sys**(gauge)                                            | The number of bytes of memory obtained from the OS for mspan structures.*Shown as byte*                         |
| **tekton.pipelines\_controller.go.next\_gc**(gauge)                                              | The target heap size of the next GC cycle.*Shown as byte*                                                       |
| **tekton.pipelines\_controller.go.num\_forced\_gc**(gauge)                                       | The number of GC cycles that were forced by the application calling the GC function.                            |
| **tekton.pipelines\_controller.go.num\_gc**(gauge)                                               | The number of completed GC cycles.                                                                              |
| **tekton.pipelines\_controller.go.other\_sys**(gauge)                                            | The number of bytes of memory in miscellaneous off-heap runtime allocations.*Shown as byte*                     |
| **tekton.pipelines\_controller.go.stack\_in\_use**(gauge)                                        | The number of bytes in stack spans.*Shown as byte*                                                              |
| **tekton.pipelines\_controller.go.stack\_sys**(gauge)                                            | The number of bytes of stack memory obtained from the OS.*Shown as byte*                                        |
| **tekton.pipelines\_controller.go.sys**(gauge)                                                   | The total bytes of memory obtained from the OS.*Shown as byte*                                                  |
| **tekton.pipelines\_controller.go.total\_alloc**(gauge)                                          | The cumulative bytes allocated for heap objects.*Shown as byte*                                                 |
| **tekton.pipelines\_controller.go.total\_gc\_pause**(gauge)                                      | The duration in GC stop-the-world pauses since the program started.*Shown as nanosecond*                        |
| **tekton.pipelines\_controller.pipelinerun.count**(count)                                        | Total number of PipelineRun triggered.                                                                          |
| **tekton.pipelines\_controller.pipelinerun.duration.bucket**(count)                              | Duration of the PipelineRun.*Shown as second*                                                                   |
| **tekton.pipelines\_controller.pipelinerun.duration.count**(count)                               | Duration of the PipelineRun.                                                                                    |
| **tekton.pipelines\_controller.pipelinerun.duration.sum**(count)                                 | Duration of the PipelineRun.*Shown as second*                                                                   |
| **tekton.pipelines\_controller.pipelinerun.taskrun.duration.bucket**(count)                      | Duration of the TaskRun for the PipelineRun.*Shown as second*                                                   |
| **tekton.pipelines\_controller.pipelinerun.taskrun.duration.count**(count)                       | Duration of the TaskRun for the PipelineRun.                                                                    |
| **tekton.pipelines\_controller.pipelinerun.taskrun.duration.sum**(count)                         | Duration of the TaskRun for the PipelineRun.*Shown as second*                                                   |
| **tekton.pipelines\_controller.running\_pipelineruns**(gauge)                                    | Number of running pipelineruns.                                                                                 |
| **tekton.pipelines\_controller.running\_pipelineruns\_waiting\_on\_pipeline\_resolution**(gauge) | Number of pipelineruns waiting on pipeline resolution.                                                          |
| **tekton.pipelines\_controller.running\_pipelineruns\_waiting\_on\_task\_resolution**(gauge)     | Number of pipelineruns waiting on task resolution.                                                              |
| **tekton.pipelines\_controller.running\_taskruns**(gauge)                                        | Number of running taskruns.                                                                                     |
| **tekton.pipelines\_controller.running\_taskruns\_throttled\_by\_node**(gauge)                   | Number of taskruns throttled by node.                                                                           |
| **tekton.pipelines\_controller.running\_taskruns\_throttled\_by\_quota**(gauge)                  | Number of taskruns throttled by quota.                                                                          |
| **tekton.pipelines\_controller.running\_taskruns\_waiting\_on\_task\_resolution**(gauge)         | Number of taskruns waiting on task resolution.                                                                  |
| **tekton.pipelines\_controller.taskrun.count**(count)                                            | Total number of TaskRun triggered.                                                                              |
| **tekton.pipelines\_controller.taskrun\_duration.bucket**(count)                                 | Duration of the TaskRun.*Shown as second*                                                                       |
| **tekton.pipelines\_controller.taskrun\_duration.count**(count)                                  | Duration of the TaskRun.                                                                                        |
| **tekton.pipelines\_controller.taskrun\_duration.sum**(count)                                    | Duration of the TaskRun.*Shown as second*                                                                       |
| **tekton.pipelines\_controller.taskruns\_pod\_latency**(gauge)                                   | The scheduling latency for the taskruns pods.*Shown as millisecond*                                             |
| **tekton.pipelines\_controller.workqueue.longest\_running\_processor.bucket**(count)             | Longest outstanding workqueue item has been in flight.*Shown as second*                                         |
| **tekton.pipelines\_controller.workqueue.longest\_running\_processor.count**(count)              | Longest outstanding workqueue item has been in flight.                                                          |
| **tekton.pipelines\_controller.workqueue.longest\_running\_processor.sum**(count)                | Longest outstanding workqueue item has been in flight.*Shown as second*                                         |
| **tekton.pipelines\_controller.workqueue.unfinished\_work.bucket**(count)                        | Duration an item from workqueue takes to get processed.*Shown as second*                                        |
| **tekton.pipelines\_controller.workqueue.unfinished\_work.count**(count)                         | Duration an item from workqueue takes to get processed.                                                         |
| **tekton.pipelines\_controller.workqueue.unfinished\_work.sum**(count)                           | Duration an item from workqueue takes to get processed.*Shown as second*                                        |
| **tekton.triggers\_controller.client.latency.bucket**(count)                                     | Duration of Kubernetes API requests.*Shown as second*                                                           |
| **tekton.triggers\_controller.client.latency.count**(count)                                      | Duration of Kubernetes API requests.                                                                            |
| **tekton.triggers\_controller.client.latency.sum**(count)                                        | Duration of Kubernetes API requests.*Shown as second*                                                           |
| **tekton.triggers\_controller.client.results.count**(count)                                      | Total number of API requests (broken down by status code).*Shown as request*                                    |
| **tekton.triggers\_controller.clusterinterceptor**(gauge)                                        | The number of clusterinterceptor.                                                                               |
| **tekton.triggers\_controller.clustertriggerbinding**(gauge)                                     | The number of clustertriggerbinding.                                                                            |
| **tekton.triggers\_controller.eventlistener**(gauge)                                             | The number of eventlistener.                                                                                    |
| **tekton.triggers\_controller.go.alloc**(gauge)                                                  | The number of bytes of allocated heap objects.*Shown as byte*                                                   |
| **tekton.triggers\_controller.go.bucket\_hash\_sys**(gauge)                                      | The number of bytes of memory in profiling bucket hash tables.*Shown as byte*                                   |
| **tekton.triggers\_controller.go.frees**(gauge)                                                  | The number of heap objects freed.*Shown as object*                                                              |
| **tekton.triggers\_controller.go.gc\_cpu\_fraction**(gauge)                                      | The fraction of this program's available CPU time used by the GC since the program started.*Shown as fraction*  |
| **tekton.triggers\_controller.go.gc\_sys**(gauge)                                                | The number of bytes of memory in garbage collection metadata.*Shown as byte*                                    |
| **tekton.triggers\_controller.go.heap\_alloc**(gauge)                                            | The number of bytes of allocated heap objects.*Shown as byte*                                                   |
| **tekton.triggers\_controller.go.heap\_idle**(gauge)                                             | The number of bytes in idle (unused) spans.*Shown as byte*                                                      |
| **tekton.triggers\_controller.go.heap\_in\_use**(gauge)                                          | The number of bytes in in-use spans.*Shown as byte*                                                             |
| **tekton.triggers\_controller.go.heap\_objects**(gauge)                                          | The number of allocated heap objects.*Shown as object*                                                          |
| **tekton.triggers\_controller.go.heap\_released**(gauge)                                         | The number of bytes of physical memory returned to the OS.*Shown as byte*                                       |
| **tekton.triggers\_controller.go.heap\_sys**(gauge)                                              | The number of bytes of heap memory obtained from the OS.*Shown as byte*                                         |
| **tekton.triggers\_controller.go.last\_gc**(gauge)                                               | The time the last garbage collection finished, as nanoseconds since 1970 (the UNIX epoch).*Shown as nanosecond* |
| **tekton.triggers\_controller.go.lookups**(gauge)                                                | The number of pointer lookups performed by the runtime.                                                         |
| **tekton.triggers\_controller.go.mallocs**(gauge)                                                | The number of heap objects allocated.*Shown as object*                                                          |
| **tekton.triggers\_controller.go.mcache\_in\_use**(gauge)                                        | The number of bytes of allocated mcache structures.*Shown as byte*                                              |
| **tekton.triggers\_controller.go.mcache\_sys**(gauge)                                            | The number of bytes of memory obtained from the OS for mcache structures.*Shown as byte*                        |
| **tekton.triggers\_controller.go.mspan\_in\_use**(gauge)                                         | The number of bytes of allocated mspan structures.*Shown as byte*                                               |
| **tekton.triggers\_controller.go.mspan\_sys**(gauge)                                             | The number of bytes of memory obtained from the OS for mspan structures.*Shown as byte*                         |
| **tekton.triggers\_controller.go.next\_gc**(gauge)                                               | The target heap size of the next GC cycle.*Shown as byte*                                                       |
| **tekton.triggers\_controller.go.num\_forced\_gc**(gauge)                                        | The number of GC cycles that were forced by the application calling the GC function.                            |
| **tekton.triggers\_controller.go.num\_gc**(gauge)                                                | The number of completed GC cycles.                                                                              |
| **tekton.triggers\_controller.go.other\_sys**(gauge)                                             | The number of bytes of memory in miscellaneous off-heap runtime allocations.*Shown as byte*                     |
| **tekton.triggers\_controller.go.stack\_in\_use**(gauge)                                         | The number of bytes in stack spans.*Shown as byte*                                                              |
| **tekton.triggers\_controller.go.stack\_sys**(gauge)                                             | The number of bytes of stack memory obtained from the OS.*Shown as byte*                                        |
| **tekton.triggers\_controller.go.sys**(gauge)                                                    | The total bytes of memory obtained from the OS.*Shown as byte*                                                  |
| **tekton.triggers\_controller.go.total\_alloc**(gauge)                                           | The cumulative bytes allocated for heap objects.*Shown as byte*                                                 |
| **tekton.triggers\_controller.go.total\_gc\_pause**(gauge)                                       | The duration in GC stop-the-world pauses since the program started.*Shown as nanosecond*                        |
| **tekton.triggers\_controller.reconcile.count**(count)                                           | Number of reconcile operations.*Shown as operation*                                                             |
| **tekton.triggers\_controller.reconcile\_latency.bucket**(count)                                 | Latency of reconcile operations.                                                                                |
| **tekton.triggers\_controller.reconcile\_latency.count**(count)                                  | Latency of reconcile operations.                                                                                |
| **tekton.triggers\_controller.reconcile\_latency.sum**(count)                                    | Latency of reconcile operations.*Shown as second*                                                               |
| **tekton.triggers\_controller.triggerbinding**(gauge)                                            | Number of triggerbinding.                                                                                       |
| **tekton.triggers\_controller.triggertemplate**(gauge)                                           | number of triggertemplate.                                                                                      |
| **tekton.triggers\_controller.work\_queue\_depth**(gauge)                                        | Depth of the work queue.                                                                                        |
| **tekton.triggers\_controller.workqueue.adds.count**(count)                                      | Total number of adds handled by workqueue.                                                                      |
| **tekton.triggers\_controller.workqueue.depth**(gauge)                                           | Current depth of workqueue.                                                                                     |
| **tekton.triggers\_controller.workqueue.longest\_running\_processor.bucket**(count)              | Longest outstanding workqueue item has been in flight.                                                          |
| **tekton.triggers\_controller.workqueue.longest\_running\_processor.count**(count)               | Longest outstanding workqueue item has been in flight.                                                          |
| **tekton.triggers\_controller.workqueue.longest\_running\_processor.sum**(count)                 | Longest outstanding workqueue item has been in flight.*Shown as second*                                         |
| **tekton.triggers\_controller.workqueue.queue\_latency.bucket**(count)                           | Duration an item stays in workqueue before being requested.                                                     |
| **tekton.triggers\_controller.workqueue.queue\_latency.count**(count)                            | Duration an item stays in workqueue before being requested.                                                     |
| **tekton.triggers\_controller.workqueue.queue\_latency.sum**(count)                              | Duration an item stays in workqueue before being requested.*Shown as second*                                    |
| **tekton.triggers\_controller.workqueue.unfinished\_work.bucket**(count)                         | Duration the outstanding workqueue items have been in flight.                                                   |
| **tekton.triggers\_controller.workqueue.unfinished\_work.count**(count)                          | Duration the outstanding workqueue items have been in flight.                                                   |
| **tekton.triggers\_controller.workqueue.unfinished\_work.sum**(count)                            | Duration the outstanding workqueue items have been in flight.                                                   |
| **tekton.triggers\_controller.workqueue.work\_duration.bucket**(count)                           | Duration an item from workqueue takes to get processed.                                                         |
| **tekton.triggers\_controller.workqueue.work\_duration.count**(count)                            | Duration an item from workqueue takes to get processed.                                                         |
| **tekton.triggers\_controller.workqueue.work\_duration.sum**(count)                              | Duration an item from workqueue takes to get processed.                                                         |

### Events{% #events %}

The Tekton integration does not include any events.

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

**tekton.pipelines\_controller.openmetrics.health**

Returns `CRITICAL` if the check cannot access the OpenMetrics metrics endpoint of Tekton Pipelines.

*Statuses: ok, critical*

**tekton.triggers\_controller.openmetrics.health**

Returns `CRITICAL` if the check cannot access the OpenMetrics metrics endpoint of Tekton Triggers.

*Statuses: ok, critical*

## Troubleshooting{% #troubleshooting %}

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