# Source: https://docs.datadoghq.com/developers/community/libraries.md

---
title: Libraries
description: Datadog, the leading service for cloud-scale monitoring.
breadcrumbs: Docs > Developers > Community > Libraries
---

# Libraries

## API and DogStatsD client libraries{% #api-and-dogstatsd-client-libraries %}

The following table lists Datadog-official and community contributed API and [DogStatsD](https://docs.datadoghq.com/metrics/custom_metrics/dogstatsd_metrics_submission/) client libraries. A few libraries support both the API and DogStatsD, but most focus on one or the other.

| Languages                                                                                          | Libraries                                                                      | Author                                                                                | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Arduino**                                                                                        | [ArduinoStatsd](https://github.com/aelse/ArduinoStatsd)                        | DogStatsD                                                                             | Alexander Else                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | ArduinoStatsd is a lightweight Arduino library that allows your Arduino projects to send metrics (counters, timers, gauges, and more) to StatsD servers over UDP. It supports metric tags compatible with modern StatsD implementations, making it easy to monitor and analyze your embedded devices.                                                                                                |
| **C++**                                                                                            | [cpp-datadogstatsd](https://github.com/BoardiesITSolutions/cpp-datadogstatsd)  | DogStatsD                                                                             | BoardiesITSolutions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | C++ library for sending custom metrics and events from your applications to Datadog via StatsD. Supports UDP and HTTP(S) transmission, tagging, gauge, counter, timer, set, histogram, and event types, with optional asynchronous event submission and flexible tagging APIs.                                                                                                                       |
| [DogFood](https://github.com/garrettsickles/DogFood)                                               | DogStatsD                                                                      | Garrett Sickles                                                                       | DogFood is a lightweight, header-only C++ library for reporting metrics, events, and service checks to a Datadog Agent using the DogStatsD protocol.                                                                                                                                                                                                                                                                                                                                                                                   |
| **C# / .NET**                                                                                      | [dogstatsd-csharp-client](https://github.com/DataDog/dogstatsd-csharp-client)  | OfficialDogStatsD                                                                     | Datadog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | C# client library for DogStatsD, Datadog's extension of the StatsD metric server. Features client-side metric aggregation, batching for efficient network usage, and supports Unix domain sockets (UDS) on supported platforms.                                                                                                                                                                      |
| [DatadogStatsD](https://github.com/verdie-g/DatadogStatsD)                                         | DogStatsD                                                                      | Gregoire Verdier                                                                      | High Performance DogStatsD Client for .NET Core                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **Clojure**                                                                                        | [clojure-statsd-client](https://github.com/unbounce/clojure-dogstatsd-client)  | DogStatsD                                                                             | Unbounce                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | A pragmatic Clojure wrapper for the official Java DogStatsD client, providing simple global setup and convenient functions to instrument your code with counters, gauges, histograms, and timersâwithout needing to manually manage a client instance.                                                                                                                                               |
| **CloudFormation**                                                                                 | [cdk-datadog-resources](https://github.com/NomadBlacky/cdk-datadog-resources)  | An AWS CDK construct library that wraps the DataDog/datadog-cloudformation-resources. |
| **Crystal**                                                                                        | [statsd.cr](https://github.com/miketheman/statsd.cr)                           | DogStatsD                                                                             | Mike Fiedler                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | A Crystal client library for sending metrics to StatsD servers. Supports counters, gauges, timers, and Datadog-style tags. Simple API for instrumenting your Crystal applications with real-time metrics.                                                                                                                                                                                            |
| **Delphi**                                                                                         | [datadog-delphi](https://github.com/rfrezino/datadog-delphi)                   | DogStatsD                                                                             | Rodrigo Farias Rezino                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | datadog-delphi is a StatsD client library for Delphi, enabling Delphi applications to send metrics to Datadog via the StatsD protocol.                                                                                                                                                                                                                                                               |
| **Elixir**                                                                                         | [ex-datadog-plug](https://github.com/Tubitv/ex-datadog-plug)                   | API                                                                                   | Tyr Chen, Tubi                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | An Elixir plug for automatically logging HTTP response times and related metadata to Datadog. Easily configurable to include request methods, customizable metric prefixes, and query parameter tags for enhanced observability of your Phoenix or Plug-based applications.                                                                                                                          |
| [mtx](https://github.com/synrc/mtx)                                                                | DogStatsD                                                                      | N2O Ecosystem                                                                         | MTX is an Erlang metrics library that provides a front-end API for tracking various metric types, including histograms, meters, counters, gauges, and timings.                                                                                                                                                                                                                                                                                                                                                                         |
| [statix](https://github.com/lexmag/statix)                                                         | DogStatsD                                                                      | Aleksei Magusev                                                                       | Statix is a fast and efficient Elixir client for StatsD-compatible servers, designed for high-throughput metric collection with low memory usage. It features direct socket communication, UDP packet header caching, and connection pooling to maximize performance, making it ideal for real-time monitoring and analytics in Elixir applications.                                                                                                                                                                                   |
| **Erlang / Elixir**                                                                                | [dogstatsde](https://github.com/waisbrot/dogstatsde)                           | DogStatsD                                                                             | waisbrot                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | dogstatsde is an Erlang and Elixir client for DogStatsD, Datadog's extension of StatsD that adds support for tags on metrics. The library is easy to integrate into Erlang or Elixir projects and supports tagging, batching, and sample rate for efficient metric reporting to a DogStatsD/StatsD agent.                                                                                            |
| **Go**                                                                                             | [datadog-go](https://github.com/DataDog/datadog-go)                            | OfficialDogStatsD                                                                     | Datadog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Go client library for DogStatsD, allowing you to send custom metrics, events, and service checks from your Go applications to Datadog.                                                                                                                                                                                                                                                               |
| [datadog-api-client-go](https://github.com/DataDog/datadog-api-client-go)                          | OfficialAPI                                                                    | Datadog                                                                               | Official Go client library for the Datadog API, supporting both v1 and v2 endpoints. It enables developers to interact with Datadog programmatically for tasks such as creating users, managing incidents, querying metrics, and more. The library supports pagination, configurable retries, proxies, and logging, and can be easily integrated into Go applications.                                                                                                                                                                 |
| [xstats](https://github.com/rs/xstats)                                                             | DogStatsD                                                                      | Olivier Poitrey                                                                       | xstats is a Go package for service instrumentation, providing a unified client to send various types of metrics (counters, timings, etc.) to multiple backends.                                                                                                                                                                                                                                                                                                                                                                        |
| [go-datadog-api](https://github.com/zorkian/go-datadog-api)                                        | API                                                                            | Mark Smith from Dropbox                                                               | go-datadog-api is a Go client library for interacting with the Datadog API. It supports automating tasks such as managing dashboards, monitors, alerting, and retrieving data like events from Datadog. The library provides pointer-based models with helper functions for safe value handling, and includes accessor methods for working with API objects.                                                                                                                                                                           |
| **Haskell**                                                                                        | [Haskell Datadog Client](https://github.com/iand675/datadog)                   | APIDogStatsD                                                                          | Ian Duncan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Haskell client for Datadog.                                                                                                                                                                                                                                                                                                                                                                          |
| **Java**                                                                                           | [java-dogstatsd-client](https://github.com/DataDog/java-dogstatsd-client)      | OfficialDogStatsD                                                                     | Datadog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | A Java client library for DogStatsD, enabling Java applications to send custom metrics, events, and service checks to the Datadog Agent via UDP or Unix Domain SocketsSupports modern Datadog features like origin detection and client-side aggregation to optimize performance and reduce metric traffic.                                                                                          |
| [datadog-api-client-java](https://github.com/DataDog/datadog-api-client-java)                      | OfficialAPI                                                                    | Datadog                                                                               | Official Java client library for the Datadog API. It enables developers to interact programmatically with Datadog's monitoring, dashboards, alerts, and other resources from Java applications. The client provides both synchronous and asynchronous methods (using CompletableFuture), supports configuration for unstable endpoints, server selection (such as EU instances), proxy settings, request logging, GZIP compression control, retry logic on rate limits or errors, and multiple artifact options including shaded JARs. |
| [java-dogstatsd-client](https://github.com/arnabk/java-dogstatsd-client)                           | DogStatsD                                                                      | Arnab Karmakar                                                                        | A Java client library for DogStatsD, enabling Java applications to send custom metrics, events, and service checks to the Datadog Agent via UDP or Unix Domain SocketsSupports modern Datadog features like origin detection and client-side aggregation to optimize performance and reduce metric traffic.                                                                                                                                                                                                                            |
| [metrics-datadog](https://github.com/coursera/metrics-datadog)                                     | APIDogStatsD                                                                   | Coursera                                                                              | A reporting bridge between Dropwizard metrics and Datadog.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| **Lua**                                                                                            | [APISIX](https://apisix.apache.org/docs/apisix/next/plugins/datadog/)          | DogStatsD                                                                             | Apache APISIX                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Send custom metrics to DogStatsD using the UDP protocol.                                                                                                                                                                                                                                                                                                                                             |
| **Node.js**                                                                                        | [datadog-api-client](https://github.com/DataDog/datadog-api-client-typescript) | OfficialAPI                                                                           | Datadog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Official Node.js client for interacting with the Datadog API, allowing you to programmatically manage monitors, metrics, dashboards, incidents, and more. The client offers flexible configuration for request logging, retry logic, request timeouts, and compression. It also supports unstable endpoints, pagination helpers, and can be extended for custom HTTP behavior such as proxy support. |
| [hot-shots](https://github.com/brightcove/hot-shots)                                               | DogStatsD                                                                      | Brightcove                                                                            | hot-shots is a Node.js client for sending metrics and events to StatsD servers, including Etsy's StatsD, Datadog's DogStatsD, and InfluxDB's Telegraf.                                                                                                                                                                                                                                                                                                                                                                                 |
| [node-dogstatsd](https://github.com/joybro/node-dogstatsd)                                         | DogStatsD                                                                      | Young Han Lee                                                                         | Node.js client for sending metrics to Datadog's extended StatsD server. It supports Datadog-specific features such as histograms and tags, in addition to standard StatsD metric types like counters and timers. This library allows you to easily instrument your Node.js applications with custom metrics that can be visualized and monitored in Datadog.                                                                                                                                                                           |
| [node-dogapi](https://github.com/brettlangdon/node-dogapi)                                         | API                                                                            | Brett Langdon                                                                         | dogapi is a Node.js client library for interacting with the Datadog HTTP API. It allows you to send metrics, events, and more to Datadog programmatically from your Node.js applications. In addition to its programmatic interface, dogapi offers a command-line tool for accessing Datadog API functionality from the terminal.                                                                                                                                                                                                      |
| [datadog-metrics](https://github.com/dbader/node-datadog-metrics)                                  | API                                                                            | Daniel Bader                                                                          | datadog-metrics is a Node.js library for collecting and sending custom application metrics to Datadog via its HTTP API, without needing the Datadog Agent. It buffers metrics locally for efficient, periodic submission, minimizing performance impact. datadog-metrics is ideal for environments like serverless or containers where installing the Datadog Agent is not feasible.                                                                                                                                                   |
| **Perl**                                                                                           | [dogstatsd-perl](https://github.com/binary-com/dogstatsd-perl)                 | DogStatsD                                                                             | Stefan Goethals                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | DataDogStatsd is a Perl client for DogStatsd, enabling applications to send metrics and events to Datadog. This module supports counters, gauges, histograms, timings, sets, and events with optional tags and namespaces for flexible metric organization.                                                                                                                                          |
| **PHP**                                                                                            | [php-datadogstatsd](https://github.com/DataDog/php-datadogstatsd)              | OfficialDogStatsD                                                                     | Alex Corley                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | php-datadogstatsd is a simple PHP client for sending custom metrics, events, and service checks to Datadog via DogStatsD. The library requires the PHP sockets extension and is suitable for integration into any PHP project; a Laravel-specific wrapper is also available.                                                                                                                         |
| [dog-statsd](https://github.com/graze/dog-statsd)                                                  | DogStatsD                                                                      | graze.com                                                                             | A fork of thephpleague/statsd with additional Datadog features by Graze.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| **Python**                                                                                         | [datadogpy](https://github.com/DataDog/datadogpy)                              | OfficialAPIDogStatsD                                                                  | Datadog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | The Datadog Python library (datadogpy) provides convenient interfaces for interacting with Datadog's HTTP API and sending metrics, events, and service checks via DogStatsD. It supports both UDP and Unix Domain Socket (UDS) transports for DogStatsD. It also provides a CLI tool ('dog') for API operations.                                                                                     |
| [datadog-api-client-python](https://github.com/DataDog/datadog-api-client-python)                  | OfficialAPI                                                                    | Datadog                                                                               | Official Python client library for the Datadog API, providing both synchronous and asynchronous (asyncio) interfaces, and includes features like pagination, retry on rate limiting, proxy configuration, and support for unstable endpoints.                                                                                                                                                                                                                                                                                          |
| **R**                                                                                              | [datadogr](https://cran.r-project.org/package=datadogr)                        | API                                                                                   | A simple R package to query for metrics.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [rdog](https://github.com/alq666/rdog)                                                             | API                                                                            | Alexis LÃª-QuÃ´c                                                                        | An R package to analyze Datadog metrics into R.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **Racket**                                                                                         | [racket-dogstatsd](https://github.com/DarrenN/racket-dogstatsd)                | DogStatsD                                                                             | DarrenN                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | racket-dogstatsd is a DogStatsD client library for Racket, providing functions to send metrics, events, and service checks to Datadog. It supports counters, gauges, timers, histograms, and tagging, and includes convenient macros like with-timer for measuring code execution time. Requires Racket 6.3 or later.                                                                                |
| **Ruby**                                                                                           | [DogApi](https://github.com/DataDog/dogapi-rb)                                 | OfficialAPI                                                                           | Datadog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | DogApi is a Ruby client library for interacting with the Datadog API, designed to simplify the process of reporting events and metrics from your Ruby applications or scripts. It provides a higher-level abstraction over Datadog's HTTP API, making it easy to submit metrics, send events, tag hosts, and retrieve metric data.                                                                   |
| [datadog_api_client](https://github.com/DataDog/datadog-api-client-ruby)                           | OfficialAPI                                                                    | Datadog                                                                               | Ruby client for interacting with the Datadog API, allowing you to manage and monitor your Datadog resources programmatically. It supports all major Datadog API endpoints, including unstable/beta features, and offers flexible configuration for authentication, server selection, logging, proxy support, pagination, and automatic retries.                                                                                                                                                                                        |
| [dogstatsd-ruby](https://github.com/DataDog/dogstatsd-ruby)                                        | OfficialDogStatsD                                                              | Datadog                                                                               | dogstatsd-ruby enables you to send custom metrics, events, and service checks from your Ruby applications to the Datadog Agent via UDP or Unix Domain Sockets. The library supports advanced features such as asynchronous metric buffering with a dedicated sender thread for high performance, configurable packet sizes, tagging, sample rates, and origin detection for Kubernetes pods.                                                                                                                                           |
| **Rust**                                                                                           | [cadence](https://docs.rs/cadence/latest/cadence/)                             | DogStatsD                                                                             | Nick Pillitteri                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [metrics-exporter-statsd](https://docs.rs/metrics-exporter-statsd/latest/metrics_exporter_statsd/) | DogStatsD                                                                      | GitHub                                                                                |
| [datadog-api-client-rust](https://github.com/DataDog/datadog-api-client-rust)                      | OfficialAPI                                                                    | Datadog                                                                               | Rust client library for interacting with the Datadog API, generated from Datadog's public OpenAPI specifications.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| **Scala**                                                                                          | [datadog-scala](https://github.com/gphat/datadog-scala)                        | API                                                                                   | Cory Watson                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Datadog-Scala is a Scala client library for interacting with the Datadog API.                                                                                                                                                                                                                                                                                                                        |
| [datadog4s](https://github.com/avast/datadog4s)                                                    | DogStatsD                                                                      | Avast                                                                                 | Toolkit for monitoring applications written in functional Scala using Datadog.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [scaladog](https://github.com/NomadBlacky/scaladog)                                                | API                                                                            | NomadBlacky                                                                           | Datadog API client for Scala.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| **Swift**                                                                                          | [DatadogSDK](https://github.com/DataDog/dd-sdk-ios)                            | OfficialAPI                                                                           | Datadog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | The Datadog SDK for iOS and tvOS enables seamless monitoring and observability for your mobile applications. It provides Swift and Objective-C libraries to collect logs, traces, and Real User Monitoring (RUM) events, with support for WebView tracking to monitor hybrid apps.                                                                                                                   |
| **Swift**                                                                                          | [Swift-Dogstatsd](https://github.com/datadog/swift-dogstatsd/)                 | OfficialDogStatsD                                                                     | Datadog                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Swift Dogstatsd provides an easy way to send Dogstatsd metrics from your Vapor applications. It supports both UDP and UDS transports for metrics delivery and integrates seamlessly with Application and Request contexts, allowing you to increment counters, set gauges, and more with simple method calls.                                                                                        |
| **Swift**                                                                                          | [SwiftDog](https://github.com/jaronoff97/SwiftDog)                             | API                                                                                   | Jacob Aronoff                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Swift library for sending metrics and events to the Datadog API. It allows you to easily report custom metrics and events from your iOS or macOS app, with support for customizable tags, event priorities, and alert types. SwiftDog can be integrated using Swift Package Manager or CocoaPods, and requires a configuration file with your Datadog API and app keys.                              |

## APM & Continuous Profiler client libraries{% #apm--continuous-profiler-client-libraries %}

The following table lists Datadog-official and community contributed [trace](https://docs.datadoghq.com/tracing/) client libraries.

| Languages                                                                             | Libraries                                                     | Official                                                                                                                                                                                                                                                                                                                         | Author                                                                                                                                                                                                                                                                                                      | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ------------------------------------------------------------------------------------- | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **C++**                                                                               | [dd-trace-cpp](https://github.com/DataDog/dd-trace-cpp)       | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | C++ library for instrumenting applications with Datadog distributed tracing. It allows developers to create and manage spans, propagate trace context, and add custom tags. Compatible with C++17, dd-trace-cpp can be built as a static or shared library and is tested on major platforms, including Linux, Windows, and macOS.                                                                                                                                                                  |
| **.NET**                                                                              | [dd-trace-dotnet](https://github.com/DataDog/dd-trace-dotnet) | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | The Datadog .NET Tracer enables distributed tracing, application performance monitoring, application security management, continuous integration visibility, and dynamic instrumentation. It supports a wide range of libraries out-of-the-box, with options for custom instrumentation. Also includes a continuous profiler for automatic application profiling.                                                                                                                                  |
| **Rust/C++/C**                                                                        | [ddprof](https://github.com/DataDog/ddprof)                   | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | ddprof is a command-line profiler for compiled languages that collects CPU and memory allocation data, capturing profiling information with minimal performance overhead.                                                                                                                                                                                                                                                                                                                          |
| **Elixir**                                                                            | [spandex](https://github.com/zachdaniel/spandex)              | Zach Daniel                                                                                                                                                                                                                                                                                                                      | Spandex is an Elixir library for instrumenting applications with distributed tracing, with built-in support for exporting trace data to Datadog. It provides macros and functions to create and manage spans, supports asynchronous trace propagation, and integrates with Phoenix via middleware plugs.    |
| **Go**                                                                                | [dd-trace-go](https://github.com/DataDog/dd-trace-go)         | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | Datadog's APM tracer library for Go automatically instruments HTTP, gRPC, and database operations, providing visibility into request flows across services. Supports OpenTelemetry integration and custom instrumentation. Enables correlation of traces with logs and metrics in Datadog, helping identify performance bottlenecks and errors in distributed systems.                                                                                                                             |
| [datadog-go](https://github.com/savaki/datadog)                                       | Matt Ho                                                       | Go client library for DogStatsD, allowing you to send custom metrics, events, and service checks from your Go applications to Datadog.                                                                                                                                                                                           |
| **Java**                                                                              | [dd-trace-java](https://github.com/DataDog/dd-trace-java)     | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | dd-trace-java is Datadog's Java tracer library for Application Performance Monitoring (APM). It enables automatic and manual tracing and profiling of Java applications, providing features such as distributed tracing, continuous profiling, error tracking, CI visibility, deployment tracking, and code hotspot identification. The library supports automatic instrumentation of common Java frameworks and libraries, and offers APIs for custom instrumentation and advanced configuration. |
| [apm-client](https://github.com/chonton/apm-client)                                   | Chas Honton                                                   | The apm-client library provides Java-based instrumentation for tracing servlet requests, JAX-RS client and server requests, and CDI bean methods. It generates spans containing resource and method names, wall time, and duration, which are then sent to a local Datadog APM collector via REST.                               |
| **Node.js**                                                                           | [dd-trace-js](https://github.com/DataDog/dd-trace-js)         | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | dd-trace-js is Datadog's APM (Application Performance Monitoring) tracer library for Node.js applications. It enables automatic and manual tracing of application performance, distributed traces, and integrates with the Datadog Agent to report telemetry data. Supports integration with the OpenTelemetry API for custom instrumentation.                                                                                                                                                     |
| **PHP**                                                                               | [dd-trace-php](https://github.com/DataDog/dd-trace-php/)      | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | dd-trace-php is Datadog's PHP tracing library that enables Application Performance Monitoring (APM) and distributed tracing for PHP applications. It provides automatic and manual instrumentation for popular PHP frameworks, libraries, and datastores.                                                                                                                                                                                                                                          |
| **Python**                                                                            | [dd-trace-py](https://github.com/DataDog/dd-trace-py)         | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | The dd-trace-py library enables Datadog APM features for Python applications, including distributed tracing, continuous profiling, error tracking, CI visibility, deployment tracking, code hotspots, and dynamic instrumentation. It provides automatic and manual instrumentation for various Python frameworks and libraries.                                                                                                                                                                   |
| **Ruby**                                                                              | [dd-trace-rb](https://github.com/DataDog/dd-trace-rb)         | yes                                                                                                                                                                                                                                                                                                                              | Datadog                                                                                                                                                                                                                                                                                                     | Datadog's official Application Performance Monitoring (APM) tracer. Collects distributed traces and performance metrics from Ruby applications and supports automatic instrumentation for popular Ruby frameworks and libraries.                                                                                                                                                                                                                                                                   |
| [ddtrace-rb-method-wrapper](https://github.com/brandfolder/ddtrace-rb-method-wrapper) | Brandfolder                                                   | ddtrace-method-wrapper is an extension for ddtrace, Datadog's Ruby tracing library, that provides a convenient way to instrument specific methods within a class or module. By extending your class with DatadogTraceWrapper and specifying methods to trace, this wrapper automatically creates custom spans for those methods. |
| **Rust**                                                                              | [datadog-apm](https://github.com/pipefy/datadog-apm-rust)     | Pipefy                                                                                                                                                                                                                                                                                                                           | An unofficial library for integrating Datadog Application Performance Monitoring (APM) with Rust applications. Enables collection and reporting of tracing data to Datadog, allowing developers to monitor and analyze application performance. See the documentation and examples for integration details. |

## Serverless client libraries{% #serverless-client-libraries %}

The following table lists Datadog-official and community contributed [serverless](https://docs.datadoghq.com/serverless/) client libraries.

| Languages                                                                            | Libraries                                                                 | Official                                                                                                                          | Author                                                                                                                                                                                                                                                                                                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Lambda**                                                                           | [datadog-lambda-python](https://github.com/DataDog/datadog-lambda-python) | yes                                                                                                                               | Datadog                                                                                                                                                                                                                                                                                                                                                                                                   | Provides automatic collection of enhanced Lambda metrics, distributed tracing, and enables custom metric submission to Datadog. The library supports tagging telemetry, capturing Lambda request and response payloads, filtering sensitive information from logs and traces, and advanced cold start tracing options. Optional continuous profiling allows collection of CPU and memory snapshots during Lambda execution. |
| [datadog-lambda-js](https://github.com/DataDog/datadog-lambda-js)                    | yes                                                                       | Datadog                                                                                                                           | datadog-lambda-js library captures traces, logs, and metrics, and provides options to tag telemetry, scrub sensitive data, and capture Lambda request/response payloads. It also supports cold start tracing, fine-grained payload depth controls, and profiling.                                                                                                                                         |
| [datadog-lambda-rb](https://github.com/DataDog/datadog-lambda-rb)                    | yes                                                                       | Datadog                                                                                                                           | The datadog-lambda-rb library enables enhanced metrics, distributed tracing, and custom metric submission for AWS Lambda functions written in Ruby, with automatic correlation between logs and traces.                                                                                                                                                                                                   |
| [datadog-lambda-go](https://github.com/DataDog/datadog-lambda-go)                    | yes                                                                       | Datadog                                                                                                                           | Offical library for Go-based AWS Lambda functions to send enhanced Lambda metrics, custom metrics, and distributed traces to Datadog. It supports integration with Datadog tracing by injecting spans into the function context, allowing for trace propagation and creation of custom spans using dd-trace-go. The library can also unify traces from AWS X-Ray and Datadog.                             |
| [datadog-lambda-java](https://github.com/DataDog/datadog-lambda-java)                | yes                                                                       | Datadog                                                                                                                           | Official Java client library for AWS Lambda functions that enables enhanced Lambda metrics, distributed tracing, and submission of custom metrics to Datadog. It supports automatic injection of trace headers for outbound HTTP requests 3, allowing for distributed tracing across serverless and serverful environments.                                                                               |
| [serverless-plugin-datadog](https://github.com/DataDog/serverless-plugin-datadog)    | yes                                                                       | Datadog                                                                                                                           | serverless-plugin-datadog is a Serverless Framework plugin that automates Datadog integration for AWS Lambda applications. . The plugin enables collection of enhanced metrics, distributed traces, and logs, and supports features like AWS X-Ray tracing, App and API Protection (AAP), source code integration, and continuous profiling. Supports Node.js, Python, Ruby, Java, Go, and .NET runtimes. |
| [serverless-datadog-metrics](https://github.com/DanteInc/serverless-datadog-metrics) | Dante Consulting, Inc.                                                    | This library logs useful metrics from AWS Lambda functions, so that they can be accumulated via Datadog's AWS Lambda integration. |

## Log management client libraries{% #log-management-client-libraries %}

The following table lists Datadog-official and community contributed log management client libraries.

| Type        | Libraries                                                                            | Official         | Author                                                                                  | Notes |
| ----------- | ------------------------------------------------------------------------------------ | ---------------- | --------------------------------------------------------------------------------------- | ----- |
| **Laravel** | [laravel-datadog-logger](https://github.com/myLocalInfluence/laravel-datadog-logger) | AurÃ©lien SCHILTZ | Logger, handler, and formatter created for DataDog log management on Laravel framework. |

## Community-contributed libraries{% #community-contributed-libraries %}

| Libraries                                                                       | Author                                                                                                                                                                                                                                                                                                                                                          | Notes                                                                                                                                                                                                                                                                                                                                                        |
| ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Monitors**                                                                    | [interferon](https://github.com/airbnb/interferon)                                                                                                                                                                                                                                                                                                              | Airbnb                                                                                                                                                                                                                                                                                                                                                       | The Interferon gem enables you to manage alert configurations as code by defining alerts, hosts, and engineer groups in Ruby DSL and YAML files. It supports integration with Datadog as the alerting destination, allowing you to programmatically generate and update Datadog alerts based on custom logic and inventory sources (such as AWS resources or SmartStack services). |
| [terraform-datadog](https://www.terraform.io/docs/providers/datadog/)           | Terraform                                                                                                                                                                                                                                                                                                                                                       | Official Terraform provider for Datadog                                                                                                                                                                                                                                                                                                                      |
| [datadog-to-terraform](https://github.com/intercom/datadog-to-terraform)        | Intercom                                                                                                                                                                                                                                                                                                                                                        | datadog-to-terraform is a browser extension that converts Datadog monitor and dashboard JSON configurations into Terraform code. Users can copy JSON from the Datadog UI, provide a resource name, and generate Terraform HCL for use in infrastructure-as-code workflows.                                                                                   |
| **Integrations**                                                                | [k6-datadog](https://k6.io/docs/results-output/real-time/datadog/)                                                                                                                                                                                                                                                                                              | Integration for sending K6 test results to Datadog                                                                                                                                                                                                                                                                                                           |
| [pid-stats](https://github.com/gitterHQ/pid-stats)                              | GitterHQ                                                                                                                                                                                                                                                                                                                                                        | The pid-stats integration collects resource usage metrics for processes specified by PID files and sends them to StatsD, allowing monitoring in Datadog. It samples metrics such as CPU usage (user, system, guest), memory usage (resident, virtual, percent), memory faults (major, minor), and disk I/O (read, write, cancelled) for each target process. |
| [pulumi-datadog](https://www.pulumi.com/registry/packages/datadog/)             | Datadog resource provider for Pulumi                                                                                                                                                                                                                                                                                                                            |
| [saltstack-datadog](https://github.com/DataDog/datadog-formula)                 | SaltStack formula for Datadog                                                                                                                                                                                                                                                                                                                                   |
| [sensu-datadog](https://github.com/sensu-plugins/sensu-plugins-datadog)         | Sensu handlers for sending metrics and events to Datadog                                                                                                                                                                                                                                                                                                        |
| [stackstorm-datadog](https://github.com/StackStorm-Exchange/stackstorm-datadog) | Enables StackStorm to interact with Datadog by providing actions for managing monitors, events, metrics, dashboards (screenboards and timeboards), downtimes, tags, hosts, users, and embeds. It supports posting and querying time-series data, managing and muting monitors, handling events and comments, scheduling downtimes, and managing visualizations. |
| **Agent Ports**                                                                 | [nixos-dd-agent](https://github.com/NixOS/nixpkgs/tree/master/pkgs/tools/networking/dd-agent)                                                                                                                                                                                                                                                                   | NixOS package for the Datadog agent                                                                                                                                                                                                                                                                                                                          |