Datadog

Overview

Datadog is a comprehensive, cloud-native observability platform designed to monitor and analyze the performance of applications, infrastructure, and user experiences across various environments. Founded in 2010, the platform provides unified visibility by integrating metrics, logs, and traces into a single interface. This consolidated approach helps development, operations, and security teams identify and resolve issues more rapidly.

The platform is engineered for large-scale cloud and hybrid environments, supporting a wide range of technologies from traditional servers and databases to modern serverless functions and container orchestration systems. Datadog's core products include infrastructure monitoring for collecting metrics from hosts and containers, log management for centralized log aggregation and analysis, and application performance monitoring (APM) for tracing requests across distributed services. Real user monitoring (RUM) and synthetic monitoring extend visibility to end-user experience, while security monitoring and continuous profiler address security and code optimization needs.

Datadog is often utilized by DevOps teams and organizations requiring full-stack observability to manage complex, distributed systems. Its strength lies in its ability to correlate data across different layers of the technology stack, which aids in root cause analysis and performance optimization. The platform offers a wide array of client libraries and integrations, simplifying the instrumentation process for various programming languages and services. Organizations can instrument applications using Datadog's official SDKs for languages such as Python, Go, Java, and Node.js, among others.

While Datadog provides extensive monitoring capabilities, its module-based pricing model can lead to variable costs depending on the specific products and scale of usage. It is best suited for organizations that require deep insights across their entire technology landscape and can benefit from a unified platform rather than managing disparate monitoring tools. Similar platforms, such as Dynatrace's full-stack monitoring, also aim to provide comprehensive observability by combining various monitoring disciplines.

Key features

• Infrastructure Monitoring: Collects metrics, events, and metadata from servers, containers, and cloud instances to provide real-time visibility into system health and performance.
• Log Management: Aggregates logs from all sources, allowing for centralized search, filtering, analysis, and alerting on log data.
• Application Performance Monitoring (APM): Traces requests across distributed services, identifying bottlenecks and performance issues within applications.
• Real User Monitoring (RUM): Monitors the experience of actual end-users interacting with web and mobile applications, capturing performance metrics and user journeys.
• Synthetic Monitoring: Proactively tests application availability and performance from various global locations using simulated user interactions and API checks.
• Security Monitoring: Detects threats, vulnerabilities, and misconfigurations across the application and infrastructure stack using security analytics and threat intelligence.
• Continuous Profiler: Provides always-on code-level performance analysis in production, helping developers optimize code execution and resource utilization.
• Cloud Cost Management: Offers visibility into cloud spending across providers, identifying cost optimization opportunities and tracking budget adherence.
• Custom Dashboards and Alerting: Allows users to create customizable dashboards to visualize data and configure alerts based on specific metrics and thresholds.

Pricing

Datadog employs a module-based, pay-as-you-go pricing model, with costs varying significantly based on the specific products used and the volume of usage (e.g., number of hosts, log volume, trace volume, RUM sessions). Discounts are typically available for annual commitments. The information below is accurate as of May 2026.

For detailed and up-to-date pricing, refer to the official Datadog pricing page.

Common integrations

• Cloud Providers: Amazon Web Services (AWS), Google Cloud Platform (GCP), Microsoft Azure. AWS integration guide.
• Container Orchestration: Kubernetes, Docker. Kubernetes monitoring setup.
• Databases: MySQL, PostgreSQL, MongoDB, Redis. MySQL integration.
• Web Servers: Nginx, Apache HTTP Server. Nginx integration details.
• Messaging Queues: Apache Kafka, RabbitMQ. Kafka monitoring.
• Serverless: AWS Lambda, Google Cloud Functions, Azure Functions. Serverless monitoring documentation.
• Collaboration & Alerting: Slack, PagerDuty, Jira. Slack integration guide.

Alternatives

• New Relic: Another full-stack observability platform offering APM, infrastructure monitoring, logs, and RUM.
• Dynatrace: An AI-powered observability platform known for its automated full-stack monitoring and AIOps capabilities.
• Splunk: Primarily known for log management and security information and event management (SIEM), but also offers observability solutions.

Getting started

To begin sending metrics and traces to Datadog from a Python application, you typically install the Datadog Agent on your host and use the Datadog APM client library within your application. The following example demonstrates basic setup for a Python application using ddtrace:

# First, ensure you have the Datadog Agent running on your host.
# Then, install the ddtrace library:
# pip install ddtrace

import logging
import os

from ddtrace import patch_all, tracer

# Patch common libraries for automatic tracing
patch_all()

# Configure the tracer (optional, usually picked up from env vars)
# tracer.configure(
#     hostname='localhost', # Or your Datadog Agent host
#     port=8126,
# )

# Set service name, environment, and version (recommended)
os.environ['DD_SERVICE'] = 'my-python-app'
os.environ['DD_ENV'] = 'development'
os.environ['DD_VERSION'] = '1.0.0'

log = logging.getLogger(__name__)

@tracer.wrap()
def my_traced_function():
    log.info("Executing a traced function.")
    # Simulate some work
    with tracer.trace("child.span", service="my-python-app") as span:
        span.set_tag("custom.tag", "value")
        log.debug("Inside child span.")
    return "Hello, Datadog!"

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    print(my_traced_function())
    print("Check your Datadog dashboard for traces and logs.")

This Python code snippet initializes the Datadog tracer, patches common libraries for automatic instrumentation, and defines a function that will be traced. Ensure the Datadog Agent is running and accessible from your application to collect these traces and logs. For more detailed instructions, consult the Datadog Python APM setup guide.