Migrate from Datadog

Squasher does not accept Datadog’s own data formats. You move logs, traces, and metrics to OpenTelemetry, and errors to a Squasher SDK. While you move, Datadog monitor alerts can open incidents in Squasher.

What moves and what does not

In Datadog	In Squasher	Notes
Logs from the Datadog Agent	Logs	Squasher cannot receive logs from the Agent. Read the same files with an OpenTelemetry Collector.
Logs sent to the HTTP intake	Logs	Squasher has no Datadog intake endpoint. Send to the Squasher HTTP API.
APM traces from `dd-trace`	Traces	Squasher does not accept Datadog trace formats. Instrument with OpenTelemetry.
Metrics	Metrics	Squasher accepts metrics over OTLP.
Error Tracking	Issues	Error-level logs and SDK errors open issues.
RUM	Browser SDK	Errors, Web Vitals, and session replay. See the Browser SDK.
Synthetics API tests	Uptime monitors	HTTP, SSL, TCP, DNS, and other checks. Browser tests have no equivalent.
Log and metric monitors	Query monitors	Recreate them by hand. See Status monitoring.
Dashboards	Dashboards	Recreate them by hand or as code.
On-call	On-call schedules	Weekly rotations only. Squasher has no escalation policies and does not call or text people.
Saved views, facets, notebooks	Not imported	Squasher has no importer for Datadog objects.

Run both tools side by side

Leave the Datadog Agent and tracers in place while you add Squasher:

Copy the logs. Run an OpenTelemetry Collector next to the Agent. It reads the same log files and sends a copy to Squasher. Datadog keeps its data.
Forward monitor alerts. Connect Datadog monitor alerts. Each alert opens an incident in Squasher, so responders can use Squasher incidents before you move the monitors.

Send logs from Datadog Agent hosts

The Datadog Agent sends logs in Datadog’s format, and Squasher does not accept it. Run the OpenTelemetry Collector (the otelcol-contrib build) on the same hosts, and let it read the same files.

Configure the Collector

otel-collector-config.yaml

receivers:
  filelog:
    include: [/var/log/checkout-api/*.log]
    operators:
      - type: json_parser
        severity:
          parse_from: attributes.level

processors:
  resource:
    attributes:
      - key: service.name
        value: checkout-api
        action: upsert
      - key: deployment.environment.name
        value: production
        action: upsert
  batch: {}

exporters:
  otlphttp/squasher:
    endpoint: https://ingest.squasher.ai
    headers:
      x-squasher-key: ${env:SQUASHER_API_KEY}

service:
  pipelines:
    logs:
      receivers: [filelog]
      processors: [resource, batch]
      exporters: [otlphttp/squasher]

json_parser reads JSON log lines and takes the severity from their level field. Squasher opens issues for lines at error or fatal. Lines without a severity are stored, but they do not open issues.

Start the Collector

Set SQUASHER_API_KEY in the Collector’s environment, then start it:

otelcol-contrib --config otel-collector-config.yaml

Check the logs

Write one error line to the log file. Select Logs in the Squasher sidebar to see the line, then select Issues to see the issue that it opened.

Send logs over HTTP

Squasher has no endpoint for the Datadog HTTP intake. If your code or a shipper posts logs to Datadog over HTTP, post them to the Squasher HTTP API instead:

curl -X POST "https://ingest.squasher.ai/v1/ingest/$SQUASHER_PROJECT_ID" \
  -H "x-squasher-key: $SQUASHER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[{"message": "Payment failed", "level": "error", "environment": "production",
        "tags": {"service": "checkout-api", "host": "web-1", "team": "payments"},
        "timestamp": "2026-09-25T12:00:00Z"}]'

The body can be one event, an array of events, or newline-delimited JSON with Content-Type: application/x-ndjson. Map the Datadog fields like this:

Datadog field	Squasher field
`message`	`message`. Required on every event.
`status`	`level`. Map `emergency` and `alert` to `fatal`.
`service`	`tags.service`
`hostname`	`tags.host`
`ddtags`, such as `env:prod,team:payments`	`environment` for `env`, and one `tags` key for each other tag
`timestamp`	`timestamp`, as an ISO 8601 string or a Unix time number

An event without level counts as an error, so it can open an issue. Set level on every event, or Squasher opens issues for ordinary log lines.

Squasher reads the levels fatal, critical, error, warning, warn, info, and debug. It treats any other value as info.

Switch traces to OpenTelemetry

Replace dd-trace with the OpenTelemetry SDK for your language, and send its data to Squasher:

export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.squasher.ai
export OTEL_EXPORTER_OTLP_HEADERS="x-squasher-key=$SQUASHER_API_KEY"
export OTEL_SERVICE_NAME=checkout-api

OTLP requests do not need the project ID. See OpenTelemetry for each language.

Move alerts and on-call

Keep Datadog monitor alerts connected while both tools run.
Recreate HTTP and SSL checks as uptime monitors, and log or metric thresholds as query monitors. See Status monitoring.
Recreate the notification channels as destinations and routes: Slack, email, Telegram, webhook, or PagerDuty.
Recreate the on-call rotations: select On-call in the sidebar, then Create schedule. See On-call.

Squasher does not call or text responders, and it has no escalation policies. To keep phone paging, send Squasher incidents to PagerDuty.

Check parity

Compare the two tools for at least one week that includes a deploy:

The number of error lines per service each hour.
The top issues in Squasher against the top errors in Datadog Error Tracking.
The service, environment, and host values on the events.
One test alert from each new monitor, sent to the same channel as the Datadog alert.

Turn off Datadog

Turn off the Datadog monitors after the Squasher monitors have fired correctly.
Remove the Datadog alert connector in Squasher.
Stop the Datadog Agent on each host, and remove dd-trace from your services.

Next steps

OpenTelemetry

Send logs, traces, and metrics from any language.

Datadog monitor alerts

Open Squasher incidents from Datadog monitors.

Add monitors

Replace Datadog Synthetics and monitors.

Set up on-call

Recreate your rotations in Squasher.

Get started

Guides

Migrate from Datadog

What moves and what does not

Run both tools side by side

Send logs from Datadog Agent hosts

Send logs over HTTP

Switch traces to OpenTelemetry

Move alerts and on-call

Check parity

Turn off Datadog

Next steps

OpenTelemetry

Datadog monitor alerts

Add monitors

Set up on-call

​What moves and what does not

​Run both tools side by side

​Send logs from Datadog Agent hosts

​Send logs over HTTP

​Switch traces to OpenTelemetry

​Move alerts and on-call

​Check parity

​Turn off Datadog

​Next steps

OpenTelemetry

Datadog monitor alerts

Add monitors

Set up on-call

What moves and what does not

Run both tools side by side

Send logs from Datadog Agent hosts

Send logs over HTTP

Switch traces to OpenTelemetry

Move alerts and on-call

Check parity

Turn off Datadog

Next steps