---
title: Silk
description: Monitor Silk performance and system stats.
breadcrumbs: Docs > Integrations > Silk
---

# Silk
Supported OS Integration version4.5.0
## Overview{% #overview %}

This check monitors [Silk](https://silk.us/) through the Datadog Agent.

**Minimum Agent version:** 7.34.0

## Setup{% #setup %}

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

### Installation{% #installation %}

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

### Configuration{% #configuration %}

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

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

### Metrics{% #metrics %}

|  |
|  |
| **silk.replication.system.logical\_in**(gauge)                   | Replication system logical in                                         |
| **silk.replication.system.logical\_out**(gauge)                  | Replication system logical out                                        |
| **silk.replication.system.physical\_in**(gauge)                  | Replication system physical in                                        |
| **silk.replication.system.physical\_out**(gauge)                 | Replication system physical out                                       |
| **silk.replication.volume.logical\_in**(gauge)                   | Replication volume logical in                                         |
| **silk.replication.volume.logical\_out**(gauge)                  | Replication volume logical out                                        |
| **silk.replication.volume.physical\_in**(gauge)                  | Replication volume physical in                                        |
| **silk.replication.volume.physical\_out**(gauge)                 | Replication volume physical out                                       |
| **silk.system.block\_size.io\_ops.avg**(gauge)                   | Average system IO operations tagged by block size*Shown as operation* |
| **silk.system.block\_size.latency.inner**(gauge)                 | System inner latency tagged by block size*Shown as millisecond*       |
| **silk.system.block\_size.latency.outer**(gauge)                 | System outer latency tagged by block size*Shown as millisecond*       |
| **silk.system.block\_size.throughput.avg**(gauge)                | Average system throughput tagged by block size*Shown as megabyte*     |
| **silk.system.capacity.allocated**(gauge)                        | Allocated system capacity*Shown as kibibyte*                          |
| **silk.system.capacity.allocated\_snapshots\_and\_views**(gauge) | Allocated system capacity for snapshots and views*Shown as kibibyte*  |
| **silk.system.capacity.allocated\_volumes**(gauge)               | Allocated system capacity for volumes*Shown as kibibyte*              |
| **silk.system.capacity.curr\_dt\_chunk**(gauge)                  | Current DT chunk system capacity*Shown as kibibyte*                   |
| **silk.system.capacity.free**(gauge)                             | Free system capacity*Shown as kibibyte*                               |
| **silk.system.capacity.logical**(gauge)                          | Logical system capacity*Shown as kibibyte*                            |
| **silk.system.capacity.physical**(gauge)                         | Physical system capacity*Shown as kibibyte*                           |
| **silk.system.capacity.provisioned**(gauge)                      | Provisioned total system capacity*Shown as kibibyte*                  |
| **silk.system.capacity.provisioned\_snapshots**(gauge)           | Provisioned system capacity for snapshots*Shown as kibibyte*          |
| **silk.system.capacity.provisioned\_views**(gauge)               | Provisioned system capacity for views*Shown as kibibyte*              |
| **silk.system.capacity.provisioned\_volumes**(gauge)             | Provisioned system capacity for volumes*Shown as kibibyte*            |
| **silk.system.capacity.reserved**(gauge)                         | Reserved system capacity*Shown as kibibyte*                           |
| **silk.system.capacity.total**(gauge)                            | Total system capacity*Shown as kibibyte*                              |
| **silk.system.io\_ops.avg**(gauge)                               | Average system IO operations*Shown as operation*                      |
| **silk.system.io\_ops.max**(gauge)                               | Maximum system IO operations*Shown as operation*                      |
| **silk.system.latency.inner**(gauge)                             | System inner latency*Shown as millisecond*                            |
| **silk.system.latency.outer**(gauge)                             | System outer latency*Shown as millisecond*                            |
| **silk.system.read.io\_ops.avg**(gauge)                          | Average system read IO operations*Shown as operation*                 |
| **silk.system.read.latency.inner**(gauge)                        | System inner read latency*Shown as millisecond*                       |
| **silk.system.read.latency.outer**(gauge)                        | System outer read latency*Shown as millisecond*                       |
| **silk.system.read.throughput.avg**(gauge)                       | Average system read throughput*Shown as megabyte*                     |
| **silk.system.throughput.avg**(gauge)                            | Average system throughput*Shown as megabyte*                          |
| **silk.system.throughput.max**(gauge)                            | Maximum system throughput*Shown as megabyte*                          |
| **silk.system.views\_count**(gauge)                              | Host view count                                                       |
| **silk.system.volumes\_count**(gauge)                            | Host volume count                                                     |
| **silk.system.write.io\_ops.avg**(gauge)                         | Average system write IO operations*Shown as operation*                |
| **silk.system.write.latency.inner**(gauge)                       | System inner write latency*Shown as millisecond*                      |
| **silk.system.write.latency.outer**(gauge)                       | System outer write latency*Shown as millisecond*                      |
| **silk.system.write.throughput.avg**(gauge)                      | Average system write throughput*Shown as megabyte*                    |
| **silk.volume.block\_size.io\_ops.avg**(gauge)                   | Average volume IO operations tagged by block size*Shown as operation* |
| **silk.volume.block\_size.latency.inner**(gauge)                 | Volume inner latency tagged by block size*Shown as millisecond*       |
| **silk.volume.block\_size.latency.outer**(gauge)                 | Volume outer latency tagged by block size*Shown as millisecond*       |
| **silk.volume.block\_size.throughput.avg**(gauge)                | Average volume throughput tagged by block size*Shown as megabyte*     |
| **silk.volume.compressed\_ratio.avg**(gauge)                     | Average compressed ratio                                              |
| **silk.volume.io\_ops.avg**(gauge)                               | Average volume IO operations*Shown as operation*                      |
| **silk.volume.io\_ops.max**(gauge)                               | Maximum volume IO operations*Shown as operation*                      |
| **silk.volume.latency.inner**(gauge)                             | Volume inner latency*Shown as millisecond*                            |
| **silk.volume.latency.outer**(gauge)                             | Volume outer latency*Shown as millisecond*                            |
| **silk.volume.logical\_capacity**(gauge)                         | Volume logical capacity*Shown as kibibyte*                            |
| **silk.volume.no\_dedup**(gauge)                                 |
| **silk.volume.read.io\_ops.avg**(gauge)                          | Average volume IO read operations*Shown as operation*                 |
| **silk.volume.read.latency.inner**(gauge)                        | Volume inner read latency*Shown as millisecond*                       |
| **silk.volume.read.latency.outer**(gauge)                        | Volume outer read latency*Shown as millisecond*                       |
| **silk.volume.read.throughput.avg**(gauge)                       | Average volume read throughput*Shown as megabyte*                     |
| **silk.volume.size**(gauge)                                      | Volume size*Shown as byte*                                            |
| **silk.volume.snapshots\_logical\_capacity**(gauge)              | Volume capacity for snapshots*Shown as kibibyte*                      |
| **silk.volume.stream\_average\_compressed\_bytes**(gauge)        | Average stream compressed size*Shown as kibibyte*                     |
| **silk.volume.throughput.avg**(gauge)                            | Average volume throughput*Shown as megabyte*                          |
| **silk.volume.throughput.max**(gauge)                            | Maximum volume throughput*Shown as megabyte*                          |
| **silk.volume.write.io\_ops.avg**(gauge)                         | Average volume IO write operations*Shown as operation*                |
| **silk.volume.write.latency.inner**(gauge)                       | Volume inner write latency*Shown as millisecond*                      |
| **silk.volume.write.latency.outer**(gauge)                       | Volume outer write latency*Shown as millisecond*                      |
| **silk.volume.write.throughput.avg**(gauge)                      | Average volume write throughput*Shown as megabyte*                    |

### Events{% #events %}

The Silk integration records events emitted by the Silk server. The event levels are mapped as the following:

| Silk       | Datadog   |
| ---------- | --------- |
| `INFO`     | `info`    |
| `ERROR`    | `error`   |
| `WARNING`  | `warning` |
| `CRITICAL` | `error`   |

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

**silk.system.state**

Returns `CRITICAL` if the system is degraded, `WARNING` if the system is offline. Returns `OK` if ONLINE, `UNKNOWN` if the endpoint is is inaccessible.

*Statuses: ok, critical, unknown, warning*

**silk.server.state**

Returns `OK` if the server is ONLINE, `UNKNOWN` if the endpoint is inaccessible or returns a non-OK status. Tagged by `server_name`.

*Statuses: ok, unknown*

**silk.can\_connect**

Returns `CRITICAL` if check cannot access stats endpoints, `WARNING` if an error response is encountered. Returns `OK` otherwise.

*Statuses: ok, critical, warning*

## Troubleshooting{% #troubleshooting %}

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