Elastic makes the loudest anti-lock-in case in the category, and ships a real OpenTelemetry distribution to back it. In our 30-day PyPI snapshot, elastic-apm accounted for about of downloads across Elastic's two Python instrumentation packages. That vendor-specific path is still active and speaks Elastic's intake protocol rather than OTLP. This page examines that portability choice, how much platform you want to operate, whether the bill scales with deployment RAM-hours or records, and what happens when your product has AI in it.
| Feature | Logfire | Elastic |
|---|---|---|
| OpenTelemetry | Native, no vendor-specific agent | EDOT (their OTel distribution), or the Elastic-specific agent most installs still use |
| What you size | No observability deployment; usage scales with records | A hosted deployment: hardware profile, node capacity, zones, and scaling policy |
| Query interface | SQL (PostgreSQL syntax) | ES|QL, plus KQL and Query DSL |
| Pricing unit | Personal: 10M records free; Team: $49/month + $2/M over 10M | Deployment capacity in RAM-hours, plus transfer, snapshots, synthetics, and inference |
| Published entry configuration | Team: $49/month with 10M records included | Standard: $99/month for 120 GB storage across two zones |
| Evals & datasets | Datasets, code and LLM-judge scorers, experiments, human annotation, live evals | LLM tracing via OpenTelemetry; no evaluation workflow |
| Breadth | Observability, focused | Observability plus search and security on one platform |
| Published pricing dimension | Logfire | Elastic |
|---|---|---|
| Published entry configuration | Team: $49/month with 10M records included | Standard: $99/month for the 120 GB / 2-zone reference configuration |
| How usage changes the bill | $2 per million records beyond 10M | Deployment RAM-hours, data transfer, snapshots, synthetics, and inference |
| Other published Elastic levels | One Team plan shape; Growth is $249/month | Gold $114 · Platinum $131 · Enterprise $184 for the same reference configuration |
Calculation scope
Elastic Cloud Hosted's published monthly reference prices for Standard, Gold, Platinum, and Enterprise. Every price uses Elastic's stated cloud production configuration of 120 GB storage across two zones. The disclosure preserves that configuration instead of presenting the figures as workload-based estimates.
Basis: USD; Elastic-published Cloud Hosted monthly reference prices. Prices checked .
This compares each vendor's published monthly entry configuration without claiming the included capacity or features are equivalent.
Team plan $49 10,000,000 records $0 additional Standard · 120 GB storage · 2 zones $99 Elastic publishes these prices against the same 120 GB, two-zone reference configuration.
Gold · 120 GB storage · 2 zones $114 Platinum · 120 GB storage · 2 zones $131 Enterprise · 120 GB storage · 2 zones $184 Logfire publishes a deterministic record overage. Elastic Cloud Hosted requires a deployment choice before its capacity-based total can be calculated.
Team plan $49 (11M − 10M included) ÷ 1M × $2 $2 Node RAM-hours + add-ons Varies by deployment “Covers 10 million logs, spans, and metrics every month.”
The official calculator shows 20 million records and no extra seats totaling $69/month on Team.
“Based on cloud production config, 120 GB storage / 2 zones.”
Elastic publishes monthly reference prices of $99 Standard, $114 Gold, $131 Platinum, and $184 Enterprise for the same stated configuration.
“Each node type is priced in terms of GB of RAM per hour”
Elastic says deployment capacity is usually the largest part of the bill; data transfer, snapshots, synthetics, and inference are additional dimensions.
Elastic's APM page says “APM should be open. Period.” and backs it with OpenTelemetry semantic conventions, W3C trace context and EDOT, their own supported OTel distribution. On licensing and direction they are right. The remaining portability risk is the instrumentation an application starts with. In the 30-day PyPI snapshot behind this page, elastic-apm accounted for about 95% of downloads across elastic-apm and elastic-opentelemetry. Package downloads are not customer share, but they show that the Elastic-specific agent remains heavily downloaded and carries no deprecation notice. It is BSD-licensed and readable, but it speaks Elastic's intake protocol rather than OTLP. Elastic's migration guides show what leaving costs: for Java it is a JVM flag swap with no code changes, while custom Agent API spans must be ported to OpenTelemetry. Start on OpenTelemetry and there is no instrumentation migration to schedule.
Elastic runs the underlying cloud service, but Cloud Hosted still asks you to choose a hardware profile, node capacity, availability zones, scaling behavior, and when to upgrade. Logfire does not expose an observability deployment to size: send records and the service scales behind the usage meter.
Elastic Cloud Hosted prices node capacity in RAM-hours, with CPU and disk coupled to RAM, then adds resource dimensions such as data transfer and snapshots. Its published $99 Standard figure is tied to a 120 GB, two-zone reference configuration—not a telemetry allowance. Logfire bills records instead: Personal includes 10 million a month, while Team is $49 with the same allowance and $2 per million beyond it. The disclosure below preserves those different units rather than manufacturing a workload conversion.
Elastic covers LLM tracing through OpenTelemetry instrumentation, including LangChain, LangTrace, OpenLIT and OpenLLMetry, so the spans arrive and you can see what your model did. What is missing is the other half: datasets, scorers, experiments, human annotation. Tracing answers “what happened”; evals answer “was it any good”. If you are shipping AI features, changing a prompt without the second one is changing it and hoping.
Not in the licensing sense, and their own page says so plainly: “APM should be open. Period.” Elastic supports OpenTelemetry semantic conventions and W3C trace context, and ships EDOT, their own supported OpenTelemetry distribution. The two Python instrumentation paths are not equally common in the 30-day PyPI snapshot used here: elastic-apm had 1.76 million downloads against 86 thousand for elastic-opentelemetry, or about 95% across those two packages. Downloads are not customer share, but the Elastic-specific agent remains active and carries no deprecation notice. It is open source and speaks Elastic's intake protocol rather than OTLP, so moving off it is a migration rather than an endpoint change. Elastic's guides make the Java agent a JVM flag swap with no code changes, while custom Agent API spans must be ported to OpenTelemetry. Logfire's SDK emits OpenTelemetry already, so the same instrumentation can be pointed at another compatible OTLP backend.
Workflow, query interface, and billing. Logfire connects full-stack telemetry to datasets, evaluators, human review, and production improvement through PostgreSQL-compatible SQL and MCP. Elastic combines observability with its broader search and security platform, with Cloud Hosted priced around deployment capacity and additional resource dimensions.
Its main dimension is deployment capacity: the nodes in the deployment are priced by GB of RAM per hour, with CPU and disk scaled with RAM. Data transfer, snapshot storage, synthetics, and inference can add separate charges. Logfire prices records with no separate retention line: Personal includes 10 million a month, while Team is $49 with the same allowance and $2 per million after it.
Elastic ties the Standard price to a cloud production reference configuration with 120 GB of storage across two zones. Gold is $114, Platinum $131, and Enterprise $184 against that same stated configuration. Actual cost varies with the deployment you choose and how long its resources run, so we show the reference configuration rather than treating $99 as a workload estimate.
Elastic uses ES|QL, with KQL and Query DSL still present in parts of the product. Logfire uses PostgreSQL-compatible SQL across traces, logs, and metrics, and exposes the same query workflow to coding agents through MCP.
Elastic's APM page covers tracing LLM calls through OpenTelemetry instrumentation, including LangChain, LangTrace, OpenLIT and OpenLLMetry, so the traces arrive. What is not there is the evaluation half: datasets, scorers, experiments, human annotation. Tracing tells you what your model did; evals tell you whether it was any good, and shipping AI features without the second one means changing prompts and hoping.
Yes. Both accept OTLP, so an OpenTelemetry Collector can fan the same telemetry out to both, and you can run the same debugging task in each without instrumenting twice. That is the practical dividend of both of us being genuinely OTel-native, and it is the fairest way to choose.
Both accept OTLP, so a collector can send the same telemetry to each and you can decide on your own traces. 10 million records a month, free.