Dynatrace vs New Relic: comparing both platforms with OpenTelemetry

Dynatrace vs New Relic: an OpenTelemetry proof of concept feeding both platforms, the OTLP settings each vendor documents and an SRE scorecard to decide.
Dynatrace vs New Relic : comparer les deux plateformes avec OpenTelemetry

Dynatrace vs New Relic: on paper, both platforms cover the same needs (APM, infrastructure, logs, user experience, Kubernetes) and both accept OpenTelemetry. In a demo, it is hard to spot a difference that really matters to an on-call team.

Differences do exist, though, and they can be measured: how dependencies are modelled, the query language (DQL on one side, NRQL on the other), the effort to instrument a new service, hosting options. Because both tools speak OTLP, you can test them side by side with exactly the same instrumentation, which makes the comparison far fairer than a feature table.

This article sets out that protocol: a scorecard, a Collector feeding both platforms, and the OTLP settings each vendor documents. No prices are quoted. On the Dynatrace side, the proof of concept targets Dynatrace SaaS; differences with Dynatrace Managed are flagged.

Dynatrace vs New Relic: the fundamental differences

Criterion Dynatrace New Relic
Collection OneAgent, Dynatrace Operator on Kubernetes, native OTLP ingestion APM agents per language (Java, .NET, Node.js, Python, Go, PHP, Ruby), native OTLP ingestion
Query language DQL on Grail (SaaS) NRQL (SELECT … FROM … FACET … SINCE …)
Correlation Smartscape topology and causal analysis (Dynatrace Intelligence in SaaS, Davis AI in Managed) Entities, distributed tracing and the platform’s analysis tools
OTLP entry point https://{your-environment-id}.live.dynatrace.com/api/v2/otlp, Authorization header Regional endpoints (US, EU, JP), ports 443, 4317 and 4318, api-key header
Hosting SaaS, or Managed in your own data centre SaaS, with a choice of data region

The last point is often decisive in regulated sectors: only the Dynatrace Managed option lets you host the platform yourself (see the Dynatrace Managed architecture). For the same method applied to another vendor, see Dynatrace vs Datadog.

Proof of concept prerequisites

  • A Dynatrace SaaS trial tenant and a New Relic trial account in the region you need.
  • A Dynatrace access token with the openTelemetryTrace.ingest, metrics.ingest and logs.ingest scopes; a New Relic licence key (this is what New Relic expects in the api-key header).
  • A test Kubernetes cluster, an application instrumented with OpenTelemetry and a Collector, as in our Collector on Kubernetes guide.

Step 1: configure the SDKs once for both

Good news: both vendors recommend the same temporality for metrics. New Relic recommends preferring delta temporality (its documentation states that cumulative is accepted but uses more memory and volume), and Dynatrace expects sums in delta, as explained in OTLP metric temporality. In most SDKs, one variable is enough:

export OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=delta
export OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector.observability.svc:4318
export OTEL_SERVICE_NAME=checkout

The application only talks to the Collector; the Collector handles both destinations and their secrets.

Step 2: one Collector, two platforms

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch: {}

exporters:
  otlphttp/dynatrace:
    endpoint: https://${env:DT_ENV_ID}.live.dynatrace.com/api/v2/otlp
    headers:
      Authorization: "Api-Token ${env:DT_API_TOKEN}"
  otlphttp/newrelic:
    endpoint: https://otlp.eu01.nr-data.net
    headers:
      api-key: "${env:NEW_RELIC_LICENSE_KEY}"

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/dynatrace, otlphttp/newrelic]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/dynatrace, otlphttp/newrelic]
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/dynatrace, otlphttp/newrelic]

Critical lines:

  • otlphttp/newrelic: New Relic recommends the otlphttp exporter with a Collector. The example targets the EU endpoint; use https://otlp.nr-data.net for a US account. The exporter appends /v1/traces, /v1/metrics or /v1/logs itself.
  • api-key: without this header, New Relic returns authentication errors.
  • Authorization: "Api-Token …": mandatory prefix for a classic Dynatrace token. In Managed, the URL becomes https://{your-domain}/e/{your-environment-id}/api/v2/otlp.
  • batch: New Relic enforces payload size and rate limits; the batch processor controls batch size.

Step 3: compare on measurable criteria

Reproduce the same failure and look at what each platform tells you, and how fast.

  1. Time to diagnosis: three injected failures (slow dependency, OOMKilled, HTTP 500 after a deployment), timed by someone who does not know the scenario.
  2. Noise: number of alerts received for a single failure. See also reducing alert noise.
  3. Queries: the same question (“p95 per endpoint for the checkout service”) in DQL and in NRQL; score readability and time to a correct result.
  4. Native instrumentation: also install OneAgent and the New Relic APM agent on one service; compare what arrives without code.
  5. Predictable cost: ability to estimate next month’s bill from the usage screens.

On the Dynatrace SaaS side, the reference query:

fetch spans, from: now() - 1h
| filter service.name == "checkout"
| summarize p95 = percentile(duration, 95), calls = count(), by:{span.name}

How to check that it works

  • Dynatrace: fetch spans, from: now() - 15m | filter service.name == "checkout" | summarize count() returns spans.
  • New Relic: the checkout service appears under All entities > Services – OpenTelemetry, with its traces.
  • Collector: kubectl logs deploy/otel-collector | grep -i error shows no 401/403 (key or token) and no 404 (URL path).
  • Comparable volumes on both sides; otherwise, check sampling before comparing.

Best practices

  • Set delta temporality from the start: it avoids metric gaps that would skew the proof of concept.
  • Keep keys in Kubernetes secrets, never in the Collector ConfigMap.
  • Fix the scorecard before the proof of concept and have on-call engineers run the tests.
  • Ask for written offers on the same projected volume; for Dynatrace, cross-check them with DPS consumption tracking.

Frequently asked questions

Should we drop proprietary agents for OpenTelemetry?

Not necessarily. Native agents often bring more data without code. OpenTelemetry guarantees portability. Many teams combine both; watch out for duplicate spans in that case (see OneAgent and OpenTelemetry).

Does New Relic offer on-premises hosting?

New Relic’s OTLP documentation describes regional cloud endpoints. If self-hosting is a requirement, check it directly with the vendor; on the Dynatrace side, that is the role of Managed.

Which one is cheaper?

There is no general answer: billing units differ and depend on your volumes. Compare written offers on the same scope, projected over three years.

Conclusion

Dynatrace vs New Relic is a comparison where OpenTelemetry works in the buyer’s favour: the same instrumentation feeds both platforms, and the decision can rest on measurements (time to diagnosis, noise, queries, predictable cost) rather than on a demo.

span.observer is an independent community blog, not affiliated with Dynatrace LLC or New Relic, Inc. Dynatrace and New Relic are trademarks of their respective owners. Check settings in each vendor’s official documentation (Dynatrace, OTLP API, New Relic, OTLP).

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Dynatrace vs Grafana : plateforme intégrée ou stack Prometheus, Loki et Tempo

Dynatrace vs Grafana stack: integrated platform or Prometheus, Loki and Tempo

Next Post
Dynatrace vs AppDynamics : concepts, déploiement et POC pour une équipe SRE

Dynatrace vs AppDynamics: concepts, deployment and a proof of concept for SRE teams

Related Posts