Migrate Metrics from Datadog

Overview

This guide walks you through migrating metrics from Datadog to SigNoz. You will:

1. Check your Datadog metrics sources
2. Choose the right migration path for each metric source
3. Set up collection in SigNoz using OpenTelemetry
4. Validate that all metrics are flowing correctly

You cannot import historical metrics from Datadog. This guide focuses on redirecting your metric streams to SigNoz going forward.

Key Differences: Datadog vs SigNoz

Before migrating, understand how metric collection differs between the two platforms:

SigNoz uses open standards (OpenTelemetry, Prometheus) for collection, so your migration involves replacing Datadog agents with OpenTelemetry instrumentation or collectors.

Prerequisites

Before starting, ensure you have:

• A SigNoz account (Cloud) or a running SigNoz instance (Self-Hosted)
• Access to your Datadog account to review current metric sources
• Access to your application code or infrastructure configuration
• Administrative access to deploy the OpenTelemetry Collector (if needed)

Step 1: Assess Your Current Metrics

Before migrating, create an inventory of what you're collecting in Datadog. This ensures nothing gets lost.

Export Your Metrics List from Datadog

1. Navigate to Metrics → Summary in Datadog.
2. Export the list of metric names you're actively using.
3. Note which integrations are sending metrics (visible in the metric metadata).

Alternatively, use the Datadog API to list metrics:

curl -X GET "https://api.datadoghq.com/api/v1/metrics" \
  -H "DD-API-KEY: <DD_API_KEY>" \
  -H "DD-APPLICATION-KEY: <DD_APP_KEY>"

Categorize Your Metrics

Group your metrics by source type. Check which of these you're using:

Save this inventory. You'll use it to validate your migration is complete.

Step 2: Set Up the OpenTelemetry Collector

Most migration paths require the OpenTelemetry Collector. Set it up first:

1. Install the OpenTelemetry Collector in your environment.

2. Configure the OTLP exporter to send metrics to SigNoz Cloud

Step 3: Migrate Each Metric Source

From Datadog Agent (Host Metrics)

Replace Datadog Agent with the OpenTelemetry Collector's Host Metrics Receiver for infrastructure metrics.

Step 1: Add the hostmetrics receiver

receivers:
  hostmetrics:
    collection_interval: 60s
    scrapers:
      cpu:
      memory:
      disk:
      filesystem:
      load:
      network:
      process:
        include:
          match_type: regexp
          names: ['.*']

Step 2: Enable it in the metrics pipeline

service:
  pipelines:
    metrics:
      receivers: [hostmetrics]
      processors: [batch]
      exporters: [otlp]

See Host Metrics Receiver for all available scrapers.

From DogStatsD (Custom Metrics)

You have two options for migrating custom DogStatsD metrics:

Option A: Replace with OpenTelemetry SDK (Recommended)

Replace DogStatsD client libraries with OpenTelemetry SDKs for better integration and standardization.

Example in Python:

Before (DogStatsD):

from datadog import statsd

statsd.increment('page.views', tags=['page:home'])
statsd.gauge('users.online', 42)
statsd.histogram('request.latency', 0.5)

After (OpenTelemetry):

from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

# Setup
exporter = OTLPMetricExporter(
    endpoint="ingest.<region>.signoz.cloud:443",
    headers={"signoz-ingestion-key": "<SIGNOZ_INGESTION_KEY>"}
)
reader = PeriodicExportingMetricReader(exporter)
provider = MeterProvider(metric_readers=[reader])
metrics.set_meter_provider(provider)

meter = metrics.get_meter("my_app")

# Create instruments
page_views = meter.create_counter("page.views")
users_online = meter.create_up_down_counter("users.online")
request_latency = meter.create_histogram("request.latency")

# Record metrics
page_views.add(1, {"page": "home"})
users_online.add(42)
request_latency.record(0.5)

Option B: Use Datadog Receiver (Bridge Approach)

If you need to continue using DogStatsD during migration, configure the OpenTelemetry Collector to receive DogStatsD metrics.

See Using Datadog Receiver for detailed setup instructions.

From Datadog APM Metrics

APM metrics (like trace.servlet.request.hits, trace.servlet.request.duration) are generated from traces. When you migrate traces to SigNoz using OpenTelemetry (see Migrate Traces), SigNoz automatically generates equivalent APM metrics.

SigNoz generates these metrics from traces:

• Request rate (calls per second)
• Error rate (errors per second)
• P50, P90, P99 latency
• Apdex score

From Prometheus Exporters

If you have Prometheus exporters configured with the Datadog Agent, migrate them to the OpenTelemetry Collector's Prometheus Receiver.

Step 1: Add the Prometheus receiver

receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: 'your-app'
          scrape_interval: 60s
          static_configs:
            - targets: ['localhost:8080']
        - job_name: 'node-exporter'
          scrape_interval: 60s
          static_configs:
            - targets: ['localhost:9100']

Step 2: Enable it in the metrics pipeline

service:
  pipelines:
    metrics:
      receivers: [prometheus]
      processors: [batch]
      exporters: [otlp]

See Prometheus Metrics in SigNoz for advanced configuration.

From Cloud Integrations

SigNoz provides native integrations for major cloud providers:

These integrations collect the same cloud service metrics you were getting through Datadog.

From Datadog Integrations

For Datadog integrations (MySQL, Redis, PostgreSQL, MongoDB, etc.), use OpenTelemetry receivers:

For integrations not listed, check the OpenTelemetry Receiver Registry for available receivers.

Step 4: Import Dashboard Templates

SigNoz provides pre-built dashboards for common metrics:

1. Access the Dashboards Repository: Visit the SigNoz Dashboards Repository.

2. Choose Dashboards:

   • Host Metrics Dashboard
   • JVM Metrics Dashboard
   • MySQL/PostgreSQL Dashboards
   • And more...

3. Import Dashboards:

   • Navigate to Dashboards in SigNoz
   • Click + New Dashboard → Import JSON
   • Paste the JSON from the repository

See Migrate Dashboards for detailed instructions on recreating custom dashboards.

Validate

Compare your SigNoz metrics against your original inventory to ensure migration is complete.

1. In SigNoz, navigate to Metrics in the left sidebar.
2. Use the List View to browse available metrics.
3. Click a metric name to see its attributes and values.

Next Steps

Once your metrics are flowing to SigNoz:

• Migrate your dashboards to visualize metrics in SigNoz
• Set up alerts based on your metrics
• Migrate traces for end-to-end observability
• Migrate logs to complete your observability stack