If you instrumented your LLM applications with Arize, the thing at risk is not a feature. It is a billing unit. Arize charges you for trace spans and lets an unlimited number of people look at them. Dynatrace charges for bytes — ingested, retained, and scanned. Those two meters price the same telemetry completely differently, and the verbose full-prompt attributes your instrumentation emits by default are the difference between a rounding error and a line item your CFO asks about.
Dynatrace signed a definitive agreement to acquire Arize on August 13 for $915 million — approximately $815 million in cash plus replacement equity awards for Arize employees. The company says the deal is expected to close "later this quarter or early in Dynatrace's third quarter". Dynatrace's fiscal Q1 2027 ended June 30, 2026, which puts the central case at the end of September. You have about six weeks of leverage, and the work you should do with it is engineering work, not legal work.
What Dynatrace Actually Bought for $915 Million
Dynatrace bought the evaluation layer, and it paid a price that tells you how small the revenue underneath it is. The company says the acquisition will be approximately 200 basis points accretive to ARR growth and 175 basis points dilutive to non-GAAP operating margin for fiscal 2027. Dynatrace has not disclosed Arize's revenue, but you can back into it: full-year fiscal 2027 ARR is guided to $2,359–$2,379 million at 15–16% growth, which implies a prior-year base around $2.04 billion. Two percentage points of that is roughly $41 million. That is our arithmetic, not a disclosed figure — but at $915 million it prices Arize at something like 22 times ARR.
You do not pay 22x for revenue. You pay it for position. Arize's open-source tracing project, Phoenix, has 11,100 GitHub stars, and the company said at its $70 million Series C in February 2025 that Phoenix was seeing over two million monthly downloads. That round was led by Adams Street Partners with participation from Microsoft's M12, OMERS Ventures, PagerDuty — and Datadog. Dynatrace's closest competitor has been a shareholder in the company Dynatrace just bought.
Constellation Research's write-up of the deal quotes Dynatrace CEO Rick McConnell describing a customer running 16 observability tools at inflated cost. Consolidation is the pitch. It is a real pitch. It is also the pitch every observability acquirer has made, including Cisco when it bought Galileo and Datadog when it bought its way into adaptive ML.
Arize Bills by the Span. Dynatrace Bills by the Byte.
This is the whole story, and it is visible on two public pricing pages. Arize AX prices on trace spans per month: the free tier is 25,000 spans and 1 GB of storage at 15-day retention, Pro is $50/month for 50,000 spans and 10 GB at 30 days, Enterprise is custom volume with SaaS or self-hosted deployment. Every tier, including free, says unlimited users and unlimited evaluations.
Dynatrace does not have a users line. Its published rates are $0.20 per GiB ingested and processed, $0.0007 per GiB-day retained, and $0.0035 per GiB scanned at query time, with the first 10 days of trace retention always included. Log Analytics offers a second model — retention at $0.02 per GiB-day with queries bundled in — but Traces powered by Grail does not. For your AI spans there is no line on the rate card that buys you out of the query meter.
For contrast, Datadog's list price keeps the span unit: $160/month annual for the first 100,000 LLM spans, then $3.50 per additional 10,000 spans, with 30/60/90-day retention as separate add-ons. Three vendors, three meters. We argued in early August that the billing unit is the buying criterion in this category. This deal is the reason that argument has a deadline attached.
What "Unlimited Users" Costs on the Other Side
Run the arithmetic on your own volume before someone runs it for you. Take 500 GiB of AI traces a month — unremarkable for a production agent fleet emitting full prompts and completions — held for 30 days, at Dynatrace's published rates:
| Line | Rate | Monthly |
|---|---|---|
| Ingest & process | $0.20 / GiB | $100.00 |
| Retain, 20 chargeable days | $0.0007 / GiB-day | $7.00 |
| One full-window dashboard scan | $0.0035 / GiB-scanned | $1.75 each |
Ingest is cheap. Retention is almost free, and free outright for the first 10 days. The line that scales with your org chart is the last one. A dashboard that scans the full 30-day window costs $1.75 every time somebody opens it. Forty engineers looking five times a day across 22 working days is 4,400 scans — about $7,700 a month to look at data that cost $107 to store.
There is no bundle to buy your way out of that on traces. These are list rates and enterprise agreements are negotiated, so treat the ratio as the durable finding rather than the dollars: storing your telemetry is a rounding error, and reading it is the invoice.
Dynatrace says this out loud in its own documentation. The AI Observability FAQ warns that "some out-of-the-box AI Observability dashboards use span queries, which consume Traces powered by Grail — Query," and recommends three mitigations: apply sampling variables on dashboards, restrict dashboard access to relevant personnel, and prefer metric-based tiles over span-based ones. Read that as a product statement. "Restrict who can open the dashboard" is the operational opposite of "unlimited users," and it is the honest description of what a consumption meter does to an observability practice.
Your Instrumentation Is the Lock-In. Not the Contract.
The portability problem is in your code, and it has a documented fix that Dynatrace itself publishes. OpenInference is Arize's semantic convention — the attribute names its SDKs write onto spans. It captures llm.input_messages, llm.output_messages, input.value, output.value, retrieval.documents, and embedding.embeddings, per its own specification. Those attributes hold the literal text of every prompt, every completion, every retrieved chunk.
They are on by default. The OpenInference configuration spec lists OPENINFERENCE_HIDE_INPUTS, HIDE_OUTPUTS, HIDE_INPUT_MESSAGES, HIDE_OUTPUT_MESSAGES, HIDE_INPUT_TEXT, HIDE_OUTPUT_TEXT and HIDE_EMBEDDING_VECTORS — every one of them defaulting to False — and OPENINFERENCE_BASE64_IMAGE_MAX_LENGTH defaulting to 32,000 characters, meaning a single inline image can add roughly 32 KB to one span before anything truncates it. Arize's own masking guide confirms the posture: content capture is on unless you turn it off, and finer-grained scrubbing requires writing a custom span processor. And there is no ambient guardrail underneath — the OpenTelemetry SDK's default OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT is "no limit", with only a 128-attribute count cap.
OpenTelemetry's own GenAI conventions took the opposite default. Message content — prompts, completions, function arguments and return values — is not captured unless you set OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, which accepts span_only, event_only or span_and_event, and the newer attribute set requires OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental on top. Same telemetry, opposite default, and a deliberate design choice to put content in events where a collector can sample or drop it without touching application code.
An LLM span attribute, then, is a key-value pair written by your instrumentation library onto a trace span — and under OpenInference it carries the full text of the model call, uncapped, by default. That is the object your new vendor meters in GiB.
Here is the part nobody at either company will lead with: Dynatrace already documents the migration, and it has for months. Its OpenInference ingest guide states plainly that "because Dynatrace AI Observability requires gen_ai.* attributes, you need an intermediate normalization step," and offers two equivalent routes — an OpenTelemetry Collector transform processor running in your own infrastructure, or server-side OpenPipeline processing inside the Dynatrace tenant — covering roughly 20 mappings such as llm.model_name to gen_ai.request.model and llm.token_count.prompt to gen_ai.usage.input_tokens. Its OpenTelemetry guide lists gen_ai.provider.name, gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.input.messages and gen_ai.output.messages as the native vocabulary.
Those two routes are not equivalent for you. Collector-side normalization runs on your infrastructure, which means you decide what gets dropped before it crosses a billing boundary. OpenPipeline runs after ingest, which means you have already paid $0.20 per GiB for the attributes you are about to discard. Choose the collector.
The Open Source Is Elastic License 2.0, Not Apache
Phoenix is source-available, not OSI open source, and that distinction is exactly what a change of control tests. The press release describes Arize as "OSS-native and stack-agnostic across every major AI framework." The Phoenix repository states that "this software is licensed under the terms of the Elastic License 2.0 (ELv2)" and adds that "portions of this code are patent protected by one or more U.S. Patents." ELv2 forbids providing the software to third parties as a managed service and forbids circumventing license key functionality. It does not stop you self-hosting Phoenix for your own use — that path stays open, and it is a genuine fallback.
What it does not give you is a guarantee about version N+1. A licensor can relicense future releases, and the acquirer sets that policy after close. Dynatrace has addressed this directly and in the right direction: it says it "intends to support Phoenix and contribute to the continued stewardship of OpenInference." Take that seriously — and note that it is a statement of intent, not a licence term, and the licence is the only part that binds a future owner. We made the same argument when Anaconda acquired Enkrypt AI and when Tricentis bought Tabnine's context engine: read the license, not the press release, and pin the version you can live on. Note also that Arize AX Enterprise already offers self-hosted deployment. If you are going to need that option, get it into the contract before the counterparty changes.
The Case for Doing Nothing
The strongest version of the other side is that this deal is good for you, and it might be. Sixteen observability tools is a real problem and Dynatrace is buying a fix for it. Arize's founders Jason Lopatecki and Aparna Dhinakaran are joining Dynatrace, with Lopatecki leading the team and reporting to the CEO — which is the structure you want if you care about product continuity, and the opposite of an acquihire wind-down. And Dynatrace has said considerably more than "nothing announced yet." Its announcement blog states that after close "both will continue to operate independently," that "nothing changes immediately for customers, partners, developers, or community members," and that "existing products, relationships, and commitments remain in place." Regulatory review could stretch this into next year.
And the OpenTelemetry GenAI conventions are not finished. The specification lives in its own dedicated repository, the latest attribute set is still gated behind an experimental opt-in, and the instrumentation docs warn that it "will introduce breaking changes in future releases." Normalizing to a moving target has a cost. If you have 200,000 spans a month and one team, that cost is not worth paying today.
The counter is simple. The normalization work is small, Dynatrace publishes the mapping, and it is the same work whether you do it now or after close — except that doing it now also gives you a smaller first invoice and a credible threat to leave. That asymmetry is why the answer is "do it now" for anyone with real volume.
What to Do Before This Closes
This Week:
- Measure your bytes, not your spans. Point your existing OTLP exporter at a local collector with a file exporter and measure GiB per day of AI traces. You currently have no reason to know this number and you are about to be billed on it.
- Turn on the hide flags you do not need. Set
OPENINFERENCE_HIDE_EMBEDDING_VECTORS=truefirst — vectors are the largest, least-read attribute on any RAG trace. Then decide input/output text case by case against your eval workflow. - Pull your Arize order form and find the assignment clause. Confirm whether change of control triggers anything, when your term ends, and whether renewal pricing is fixed. Do this before anyone at Arize is a Dynatrace employee.
This Month:
- Put a normalization processor in your own collector. Use Dynatrace's published OpenInference-to-
gen_ai.*mapping, run it collector-side, and emit both conventions in parallel for a fortnight so you can diff dashboards. This is the single change that makes Datadog, New Relic, Langfuse or LangSmith a migration instead of a rewrite. - Decide where prompt content lives. Events, sampled at the collector, or span attributes, billed in full. Pick per environment: full content in staging, sampled in production, always-on for errors and tail latency.
- Count your dashboard scans, not just your ingest. Multiply your measured GiB by the number of full-window queries your org actually runs in a month. Traces carry no bundled-query option on the published rate card, so a committed query allowance or a cap is something you negotiate — and pre-close is when a vendor is most motivated to look accommodating.
Before Renewal:
- Get the self-hosting option and a price-protection window in writing. Arize AX Enterprise already lists self-hosted deployment; an option you never exercise still costs the counterparty something to grant, which is why you ask for it while they want the deal to look clean.
- Write your exit test. Stand up Phoenix on a pinned version against your normalized traces once, and record how long it took. That number is your actual leverage, and it is the only one your vendor cannot dispute.
The Bottom Line
Every observability acquisition in this cycle has followed the same shape: a specialist with a usage-friendly meter gets absorbed by a platform with a consumption meter, and the customer discovers the difference on the first invoice after close. It happened with log management a decade ago, when per-host pricing met per-GB pricing and budgets doubled without a single new deployment. We watched a version of it play out with Okta and Permiso and again with Bending Spoons and Airtable, where the repricing risk sat in credits nobody had modelled.
The defense has never been the contract. Contracts expire and get renegotiated by people who were not in the room. The defense is that your telemetry speaks a vocabulary more than one vendor reads — and in this case the acquirer has already written the translation guide and posted it publicly.
Your spans are portable or they are not. You have about six weeks to make that true.
Continue Reading
Datadog vs Arize vs LangSmith: Buy on the Billing Unit
Best AI Agent Monitoring: Langfuse, Then a Real Kill Switch
Okta Bought Permiso. Your Leverage Expires Oct 31.
Anaconda Bought Your AI Red Teamer. Read the License.
d-Matrix Bought Wallaroo. Get 'Any Hardware' in Writing.
Cisco Buys Galileo: Why AI Observability Just Became Mandatory