From d15634ae58cd9b3cd015ba7423a7b8bc94470d8b Mon Sep 17 00:00:00 2001 From: Joey Lei <6957385+leizerbeam@users.noreply.github.com> Date: Thu, 24 Sep 2026 10:27:23 -0700 Subject: [PATCH] updated guidance for logs pricing, revised manage logs usage pages, introduction of the grace period(#49656) Supabase Logs is moving to usage-based pricing. We're announcing changes early so impacted projects have time to adjust before billing begins when the grace period through early 2027. --- .../billing/pricing/pricing_logs_ingest.mdx | 9 ++- .../billing/pricing/pricing_logs_query.mdx | 8 ++- .../guides/platform/manage-your-usage.mdx | 43 ++++++++---- .../manage-your-usage/logs-ingest.mdx | 66 +++++++++++++++---- .../platform/manage-your-usage/logs-query.mdx | 60 ++++++++++------- .../platform/manage-your-usage/logs.mdx | 18 ++--- .../components/Pricing/PricingTableRow.tsx | 29 ++++++++ packages/shared-data/pricing.ts | 28 +++++++- 8 files changed, 193 insertions(+), 68 deletions(-) diff --git a/apps/docs/content/_partials/billing/pricing/pricing_logs_ingest.mdx b/apps/docs/content/_partials/billing/pricing/pricing_logs_ingest.mdx index e2d9ad37d22..ef6a5d86509 100644 --- a/apps/docs/content/_partials/billing/pricing/pricing_logs_ingest.mdx +++ b/apps/docs/content/_partials/billing/pricing/pricing_logs_ingest.mdx @@ -1 +1,8 @@ -Pricing details and included quotas will be published here when billing enforcement goes live. + per GB, after your plan's included quota. + +| Plan | Included ingest | Over-usage per GB | +| ---------- | --------------- | ------------------------------------------------------ | +| Free | 1 GB | Not billed — see [Exceeding quotas](#exceeding-quotas) | +| Pro | 20 GB | | +| Team | 20 GB | | +| Enterprise | 20 GB | | diff --git a/apps/docs/content/_partials/billing/pricing/pricing_logs_query.mdx b/apps/docs/content/_partials/billing/pricing/pricing_logs_query.mdx index e2d9ad37d22..4da7fcf07a2 100644 --- a/apps/docs/content/_partials/billing/pricing/pricing_logs_query.mdx +++ b/apps/docs/content/_partials/billing/pricing/pricing_logs_query.mdx @@ -1 +1,7 @@ -Pricing details and included quotas will be published here when billing enforcement goes live. +Every organization gets a query allowance scaled to its log ingest usage, at a fixed ratio: + +``` +Query allowance = 100 × log ingest usage +``` + +The Free Plan includes 1 GB of ingest, so it also includes 100 GB of query allowance. Paid plans include 20 GB of ingest, so they start with 2,000 GB of query allowance. If you ingest more than your plan's included amount and pay for the overage, your allowance grows at the same 100x rate. diff --git a/apps/docs/content/guides/platform/manage-your-usage.mdx b/apps/docs/content/guides/platform/manage-your-usage.mdx index 72d06b5a29d..af641fb7c96 100644 --- a/apps/docs/content/guides/platform/manage-your-usage.mdx +++ b/apps/docs/content/guides/platform/manage-your-usage.mdx @@ -5,24 +5,41 @@ title: 'Manage your usage' Each subpage breaks down a specific usage item and details what you're charged for, how costs are calculated, and how to optimize usage and reduce costs. -- [Compute](/docs/guides/platform/manage-your-usage/compute) -- [Read Replicas](/docs/guides/platform/manage-your-usage/read-replicas) +## Database + - [Branching](/docs/guides/platform/manage-your-usage/branching) -- [Egress](/docs/guides/platform/manage-your-usage/egress) +- [Compute](/docs/guides/platform/manage-your-usage/compute) +- [Disk IOPS](/docs/guides/platform/manage-your-usage/disk-iops) - [Disk Size](/docs/guides/platform/manage-your-usage/disk-size) - [Disk Throughput](/docs/guides/platform/manage-your-usage/disk-throughput) -- [Disk IOPS](/docs/guides/platform/manage-your-usage/disk-iops) -- [Monthly Active Users](/docs/guides/platform/manage-your-usage/monthly-active-users) -- [Monthly Active Third-Party Users](/docs/guides/platform/manage-your-usage/monthly-active-users-third-party) +- [Egress](/docs/guides/platform/manage-your-usage/egress) +- [IPv4](/docs/guides/platform/manage-your-usage/ipv4) +- [Pipelines](/docs/guides/platform/manage-your-usage/pipelines) +- [Point-in-Time Recovery](/docs/guides/platform/manage-your-usage/point-in-time-recovery) +- [Read Replicas](/docs/guides/platform/manage-your-usage/read-replicas) + +## Auth + +- [MFA Phone](/docs/guides/platform/manage-your-usage/advanced-mfa-phone) - [Monthly Active SSO Users](/docs/guides/platform/manage-your-usage/monthly-active-users-sso) -- [Storage Size](/docs/guides/platform/manage-your-usage/storage-size) +- [Monthly Active Third-Party Users](/docs/guides/platform/manage-your-usage/monthly-active-users-third-party) +- [Monthly Active Users](/docs/guides/platform/manage-your-usage/monthly-active-users) + +## Storage + - [Storage Image Transformations](/docs/guides/platform/manage-your-usage/storage-image-transformations) -- [Edge Function Invocations](/docs/guides/platform/manage-your-usage/edge-function-invocations) +- [Storage Size](/docs/guides/platform/manage-your-usage/storage-size) + +## Realtime + - [Realtime Messages](/docs/guides/platform/manage-your-usage/realtime-messages) - [Realtime Peak Connections](/docs/guides/platform/manage-your-usage/realtime-peak-connections) + +## Edge Functions + +- [Edge Function Invocations](/docs/guides/platform/manage-your-usage/edge-function-invocations) + +## Platform security, observability, and compliance + - [Custom Domains](/docs/guides/platform/manage-your-usage/custom-domains) -- [Point-in-Time Recovery](/docs/guides/platform/manage-your-usage/point-in-time-recovery) -- [IPv4](/docs/guides/platform/manage-your-usage/ipv4) -- [MFA Phone](/docs/guides/platform/manage-your-usage/advanced-mfa-phone) -- [Log Drains](/docs/guides/platform/manage-your-usage/log-drains) -- [Pipelines](/docs/guides/platform/manage-your-usage/pipelines) +- [Logs Ingest/Query and Log Drains](/docs/guides/platform/manage-your-usage/logs) diff --git a/apps/docs/content/guides/platform/manage-your-usage/logs-ingest.mdx b/apps/docs/content/guides/platform/manage-your-usage/logs-ingest.mdx index eb86f0ac58c..e56527c9acd 100644 --- a/apps/docs/content/guides/platform/manage-your-usage/logs-ingest.mdx +++ b/apps/docs/content/guides/platform/manage-your-usage/logs-ingest.mdx @@ -3,19 +3,19 @@ id: 'manage-usage-logs-ingest' title: 'Manage Logs Ingest usage' --- - + -Logs pricing is being rolled out. Pricing details and included quotas on this page are subject to change. This page will be updated when billing enforcement goes live. +To ensure customers have ample time to prepare, we will introduce a grace period that runs through the start of 2027 before billing begins. ## What you are charged for -You are charged for the total volume of log data that Supabase ingests across all your project's services (Postgres, API gateway, Auth, Storage, Realtime, Edge Functions, etc.) during the billing cycle, measured in GB. +You are charged for the total volume of log data that Supabase ingests across all your project's services (Postgres, API gateway, Auth, Storage, Realtime, Edge Functions, and others) during the billing cycle. ## How charges are calculated -Logs Ingest is charged per GB of log data ingested during the billing cycle. +Logs Ingest is charged per byte of log data ingested during the billing cycle. ### Usage on your invoice @@ -27,25 +27,63 @@ Usage is shown as "Logs Ingest" on your invoice. ## Billing examples -Billing examples will be published here when pricing is finalized. +Ingest is billed per byte (bytes ÷ 1,000,000,000 × $0.50), not rounded up to the next GB. These examples use fractional GB to show that precision. + +| Plan | Monthly ingest | Included | Billable overage | Cost | +| ---- | -------------- | -------- | ---------------- | ----------------------- | +| Free | 0.32 GB | 1 GB | — | | +| Paid | 19.76 GB | 20 GB | — | | +| Paid | 20.24 GB | 20 GB | 0.24 GB | | +| Paid | 27.48 GB | 20 GB | 7.48 GB | | +| Paid | 41.92 GB | 20 GB | 21.92 GB | | +| Paid | 115.06 GB | 20 GB | 95.06 GB | | ## View usage You can view Logs Ingest usage on the [organization's usage page](/dashboard/org/_/usage) of the Dashboard. The page shows the usage of all projects by default. To view the usage for a specific project, select it from the dropdown. You can also select a different time period. -{/* TODO: Add screenshots once Studio surfaces are live */} - ## Optimize usage -Every service in your Supabase project automatically generates logs — you don't write them directly. Log volume scales with your application's traffic and behavior. To reduce ingest volume: +Every service in your Supabase project generates logs automatically. Log volume scales with your application's traffic and behavior. -- **Configure Postgres logging settings.** Postgres emits logs for connections, checkpoints, statements, and more — many of which can be tuned or disabled. Adjusting settings such as `log_connections`, `log_min_duration_statement`, and `log_statement` can significantly reduce Postgres log volume. See [Customizing Postgres configs](/docs/guides/database/custom-postgres-config) for the full list of configurable parameters. -- **Reduce log-level verbosity** in your Edge Functions and server-side code (for example, `info` → `warn` in production). -- **Audit verbose application logging in your application code.** Application-level logs forwarded to Supabase services count toward ingest. -- **Cap log payload size.** Large structured payloads can inflate GB-billed volume. -- **Investigate spikes.** Use the [**Logs Explorer**](/dashboard/project/_/logs-explorer) in the Dashboard to find services or endpoints producing unusually high volume. +Reduce the volume of a log type rather than turning it off completely. Raise a threshold rather than disabling logging outright as this prevents you from having information if something goes wrong later. For example a security incident or a slow query may be completely missed. -{/* TODO: add MCP/skill guidance link when available */} +You change all of the Postgres settings below through [Custom Postgres Configuration](/guides/database/custom-postgres-config), either from the SQL Editor or the Supabase CLI. Some changes take effect immediately; others require a database restart. The CLI has a `--no-restart` option if you want to batch several changes together before restarting. See [Postgres log configuration](/guides/database/postgres/postgres-log-config) for the full list of configurable log settings and what each one does. + +### Start with the two biggest levers + +Consider these options first. They are responsible for most log volume on most projects. + +- **[`log_statement`](/guides/database/postgres/postgres-log-config#logstatement)** — set to `none` if you don't manually read through raw query logs to debug your application, for example if your team relies on an AI coding assistant, an APM tool, or the Query Performance dashboard instead. Keep `all` on if you routinely read query text in the Logs Explorer to debug issues, or you have a compliance requirement to retain a full statement audit trail; `mod` is a lighter-volume option if you only need a record of data changes. +- **[`log_min_duration_statement`](/guides/database/postgres/postgres-log-config#logmindurationstatement)** — raise the threshold (for example, from a few milliseconds to 1-2 seconds) if you only care about queries that are slow enough to notice. Keep it low only while you're actively in a performance-tuning phase, and raise it back up once that investigation is done. +- **[pgAudit](/guides/database/extensions/pgaudit)**, if enabled — this extension can be very verbose independently of `log_statement`. Turn off a broad `pgaudit.log` or `pgaudit.role` configuration if you don't need a dedicated audit trail beyond what `log_statement` already gives you. + + + +Enabling `log_statement=all`, or setting `log_min_duration_statement` to a low or `0` threshold, logs the full text of statements — including plaintext values such as passwords passed as query parameters. Before enabling either, check whether your queries carry sensitive data, and confirm who can access these logs and how long they're retained. + + + +### Check these often-overlooked settings + +- **[`log_connections` and `log_disconnections`](/guides/database/postgres/postgres-log-config#logconnections)** — turn off if you don't need a record of exactly when every connection opened and closed. Keep on if you're troubleshooting connection exhaustion or spikes, or have a security requirement to log all connection activity. If this setting is generating a lot of volume, your app may not be using a connection pooler such as Supavisor, which Supabase provides by default — connecting through the pooler reduces both log volume and the risk of running out of connections. +- **[`log_autovacuum_min_duration`](/guides/database/postgres/postgres-log-config#logautovacuumminduration)** — raise the threshold, or turn it off, if you're not actively diagnosing a table-maintenance problem. Keep it on with a reasonable threshold if you've had autovacuum-related performance issues before. +- **[`log_temp_files`](/guides/database/postgres/postgres-log-config#logtempfiles)** — turn off if you're not actively tuning query performance around memory usage. Keep it on if you're investigating slow queries related to sorting or joining large amounts of data. +- **[`log_lock_waits`](/guides/database/postgres/postgres-log-config#loglockwaits)** — turn off if you're not seeing symptoms of queries hanging. Keep it on if multiple processes write to the same data concurrently and you've seen unexplained slowdowns before. + +### Check this if your logs seem unusually large for no clear reason + +**[`log_min_messages`](/guides/database/postgres/postgres-log-config#logminmessages)** controls the verbosity of Postgres's own internal logging, separate from query activity. The default is `warning`. If this was turned up to a debug level while troubleshooting a specific issue and never turned back down, it can produce a large, ongoing volume of internal messages that aren't useful for day-to-day monitoring — check the current value and reset it if you don't recognize turning it up yourself. + +Custom RPC functions and stored procedures are also worth reviewing. A PL/pgSQL function that calls `RAISE NOTICE` or `RAISE LOG` produces log output every time it runs, independent of any of the settings above — if a frequently-called function logs on every invocation, it can account for a large, otherwise-unexplained share of your volume. + +### Settings you can generally leave alone + +[`log_checkpoints`](/guides/database/postgres/postgres-log-config#logcheckpoints), [`log_recovery_conflict_waits`](/guides/database/postgres/postgres-log-config#logrecoveryconflictwaits), `log_replication_commands`, and [`log_startup_progress_interval`](/guides/database/postgres/postgres-log-config#logstartupprogressinterval) are either low-volume by nature or only relevant if you use specific features such as replication. Unless you know you're using the related feature, these rarely contribute meaningfully to your total ingest. + +## Checking your new usage baseline + +After you change a setting, give it a day or two, then check your ingest usage trend in the Dashboard or your log volume in the Logs Explorer, to confirm the change had the effect you expected. Volume can be uneven day-to-day depending on traffic, so look at the trend over several days before drawing conclusions. If you're not sure which setting is responsible for your current usage, check which kind of log entries make up most of your volume in the Logs Explorer before changing anything. ## Exceeding Quotas diff --git a/apps/docs/content/guides/platform/manage-your-usage/logs-query.mdx b/apps/docs/content/guides/platform/manage-your-usage/logs-query.mdx index a636e53252b..f9eb27181c2 100644 --- a/apps/docs/content/guides/platform/manage-your-usage/logs-query.mdx +++ b/apps/docs/content/guides/platform/manage-your-usage/logs-query.mdx @@ -3,49 +3,61 @@ id: 'manage-usage-logs-query' title: 'Manage Logs Query usage' --- - + -Logs pricing is being rolled out. Pricing details and included quotas on this page are subject to change. This page will be updated when billing enforcement goes live. +The allowance and degraded-state consequences described on this page are not enforced yet. This page describes how enforcement will work once the grace period ends at the start of 2027. ## What you are charged for -You are charged for the volume of log data scanned when you read logs via the Studio UI, the Management API, the CLI, or any other interface, measured in GB. +Logs Query usage isn't billed directly. Instead, your organization gets a log query allowance that scales with how much log data you ingest. The allowance covers the volume of log data scanned when you read logs through the Studio UI, the Management API, the CLI, or any other interface. -## How charges are calculated - -Logs Query is charged per GB of log data scanned during the billing cycle. - -### Usage on your invoice - -Usage is shown as "Logs Query" on your invoice. - -## Pricing +## How your allowance is calculated <$Partial path="billing/pricing/pricing_logs_query.mdx" /> -## Billing examples +| Monthly ingest | Ingest overage (billed) | Query allowance | +| -------------- | ----------------------- | --------------- | +| 20 GB | 0 GB | 2,000 GB | +| 21 GB | 1 GB | 2,100 GB | +| 25 GB | 5 GB | 2,500 GB | +| 40 GB | 20 GB | 4,000 GB | +| 100 GB | 80 GB | 10,000 GB | -Billing examples will be published here when pricing is finalized. +There's no separate per-GB price for Logs Query. Your allowance is always 100 times your ingest usage for the same month. + +### Usage on your invoice + +Logs Query doesn't appear as a line item on your invoice, because it isn't billed directly. ## View usage You can view Logs Query usage on the [organization's usage page](/dashboard/org/_/usage) of the Dashboard. The page shows the usage of all projects by default. To view the usage for a specific project, select it from the dropdown. You can also select a different time period. -{/* TODO: Add screenshots once Studio surfaces are live */} - ## Optimize usage -Logs Query usage scales directly with the time range and data volume you scan. Keep usage low by: +Two people asking similar-sounding questions can generate very different amounts of usage, depending on how they ask. These tips help you avoid scanning more data than a question requires — they're habits, not restrictions, and none of them ask you to give up visibility you need. -- **Using the Logs Explorer** in the [Dashboard](/dashboard/project/_/logs-explorer) for ad-hoc queries — it surfaces the most relevant log data without over-scanning. -- **Keeping time ranges narrow.** A 1-day window scans 7× less data than a 7-day window. -- **Applying service and endpoint filters early** to reduce the volume scanned per query. -- **Avoiding frequent programmatic polling.** Repeated API or CLI log queries accumulate GB rapidly. For continuous log streaming, [Log Drains](/docs/guides/platform/manage-your-usage/log-drains) are more cost-effective. +- **Narrow your time range to what the question needs.** Query cost scales with how much data a query scans, and time range is usually the biggest factor: a 1-day window scans about 7 times less data than a 7-day window. Start with the smallest window that could contain the answer, and widen only if you don't find it. Keep a wide window when you're doing genuine historical or trend analysis on purpose — that's a real use case, only a more expensive one by nature. +- **Filter as part of the query, not after you've pulled the data.** Add filters for source, service, status code, or project before you run a search. A broad, unfiltered query scans everything in its time range, even if you only look at a fraction of the results afterwards. Filtering after the fact doesn't reduce what was already scanned. +- **Use the [Logs Explorer](/dashboard/project/_/logs-explorer) for ad-hoc digging, not scripted polling.** Every query scans data again — there's no caching benefit from asking the same question repeatedly. A script that polls the query endpoint on a schedule re-scans on every run, so it can use far more allowance than a person checking manually, even if it usually finds nothing new. +- **Use [Log Drains](/docs/guides/platform/manage-your-usage/log-drains) for anything continuous.** If you need an ongoing feed of your logs — for your own monitoring stack, alerting, or archiving — repeatedly querying for what's new since you last checked is one of the most expensive ways to get it, because each check re-scans. Drains stream logs to a destination as they arrive instead. -{/* TODO: add MCP/skill guidance link when available */} +After you change how you query, check your usage trend over the following few days rather than a single day. Usage varies with how much debugging or investigation you happen to do, so a single day's change isn't a reliable signal on its own. -## Exceeding Quotas +## When you exceed your allowance -<$Partial path="billing/exceeding_usage_quotas.mdx" /> +If you scan more log data than your allowance covers in a given month, the following month enters a degraded state: + +- Queries are rate limited to 10 per minute. +- Log retention shrinks to 24 hours (Pro, Team, and Enterprise) or 1 hour (Free). + +If you exceed your allowance again the next month, while still in that degraded state, logs access in the API and Studio UI will be cut off entirely for the month after. Access returns to normal at your next billing cycle. + +### A concrete walkthrough + +- January: You use 20 GB of ingest and 2,450 GB of query, more volume than your allowance covers. +- February: Degraded — 10 queries/min, retention shrunk to 24 hours on paid tiers, 1 hour on the Free Plan. +- March: If February also went over, that's two consecutive months, so this month is a full cutoff. +- April: Billing cycle resets, access returns to normal. This allows you to make continued efforts to optimize your log query usage. diff --git a/apps/docs/content/guides/platform/manage-your-usage/logs.mdx b/apps/docs/content/guides/platform/manage-your-usage/logs.mdx index e5917f4c3fe..e9da013deb1 100644 --- a/apps/docs/content/guides/platform/manage-your-usage/logs.mdx +++ b/apps/docs/content/guides/platform/manage-your-usage/logs.mdx @@ -3,24 +3,16 @@ id: 'manage-usage-logs' title: 'Manage Logs usage' --- - +Logs usage has two components, and only one of them is billed: -Logs pricing is being rolled out. Pricing details and included quotas on this page are subject to change. This page will be updated when billing enforcement goes live. +- **Logs Ingest** — the total GB of log data Supabase ingests across all your project's services (Postgres, API gateway, Auth, Storage, Realtime, Edge Functions, and others) during the billing cycle. Each plan includes a free quota, and usage beyond the quota is billed per GB. +- **Logs Query** — the total GB of log data scanned when you read logs through the Studio UI, the Management API, the CLI, or any other interface. Logs Query isn't billed. Instead, you get a query allowance scaled to your log ingest usage: 100 GB of allowance for every 1 GB you ingest. Once enforcement goes live, scanning more than your allowance in a month will lead to a degraded state — rate-limited queries and shorter retention — rather than a charge. - - -Logs usage is metered on two SKUs: - -- **Logs Ingest** — the total GB of log data Supabase ingests across all your project's services (Postgres, API gateway, Auth, Storage, Realtime, Edge Functions, etc.) during the billing cycle. -- **Logs Query** — the total GB of log data scanned when you read logs via the Studio UI, the Management API, the CLI, or any other interface. - -Each plan includes a free quota for both. Usage beyond the quota is billed per GB. Pricing details and quotas will be published on the per-SKU pages below when billing enforcement goes live. - -For optimization tips and billing details, see the per-SKU pages: +For optimization tips and billing details, see: - [Manage Logs Ingest usage](/docs/guides/platform/manage-your-usage/logs-ingest) - [Manage Logs Query usage](/docs/guides/platform/manage-your-usage/logs-query) ## Logs vs log drains -[Log Drains](/docs/guides/platform/manage-your-usage/log-drains) stream logs out of Supabase to external destinations (Datadog, Better Stack, your own S3 bucket, etc.) and are billed separately on drain hours and events. Draining logs does not replace or reduce Logs Ingest charges — ingest is metered when Supabase processes your logs, drains are metered when Supabase streams them out. These are separate billing primitives, not overlapping charges. +[Log Drains](/docs/guides/platform/manage-your-usage/log-drains) stream logs out of Supabase to external destinations, such as Datadog, Better Stack, or your own S3 bucket, and are billed separately on drain hours and events. Draining logs does not replace or reduce Logs Ingest charges — ingest is metered when Supabase processes your logs, drains are metered when Supabase streams them out. These are separate billing primitives, not overlapping charges. diff --git a/apps/www/components/Pricing/PricingTableRow.tsx b/apps/www/components/Pricing/PricingTableRow.tsx index a6e2b06a5fd..87f7890ead1 100644 --- a/apps/www/components/Pricing/PricingTableRow.tsx +++ b/apps/www/components/Pricing/PricingTableRow.tsx @@ -157,6 +157,35 @@ export const pricingTooltips: PricingTooltips = { ), }, + + 'platform.logIngestion': { + main: ( + + You are charged for the total volume of log data that Supabase ingests across all your + project's services (Postgres, API gateway, Auth, Storage, Realtime, Edge Functions, and + others) during the billing cycle. Read more in our{' '} + + docs + + . + + ), + }, + + 'platform.logQuery': { + main: ( + + Logs Query usage isn't billed directly. Instead, your organization gets a log query + allowance that scales with how much log data you ingest. The allowance covers the volume of + log data scanned when you read logs through the Studio UI, the Management API, the CLI, or + any other interface. Read more in our{' '} + + docs + + . + + ), + }, } export const PricingTableRowDesktop = (props: any) => { diff --git a/packages/shared-data/pricing.ts b/packages/shared-data/pricing.ts index 682be686c6a..f9ec1d9f368 100644 --- a/packages/shared-data/pricing.ts +++ b/packages/shared-data/pricing.ts @@ -65,13 +65,15 @@ export type FeatureKey = | 'functions.invocations' | 'functions.scriptSize' | 'functions.numberOfFunctions' + | 'platform.logRetention' + | 'platform.logQuery' + | 'platform.logIngestion' | 'realtime.postgresChanges' | 'realtime.concurrentConnections' | 'realtime.messagesPerMonth' | 'realtime.maxMessageSize' | 'dashboard.teamMembers' | 'security.platformAuditLogs' - | 'security.logRetention' | 'security.logDrain' | 'security.metricsEndpoint' | 'security.soc2' @@ -584,7 +586,7 @@ export const pricing: Pricing = { icon: 'M9 12.75L11.25 15 15 9.75m-3-7.036A11.959 11.959 0 013.598 6 11.99 11.99 0 003 9.749c0 5.592 3.824 10.29 9 11.623 5.176-1.332 9-6.03 9-11.622 0-1.31-.21-2.571-.598-3.751h-.152c-3.196 0-6.1-1.248-8.25-3.285z', features: [ { - key: 'security.logRetention', + key: 'platform.logRetention', title: 'Log retention (API & Database)', plans: { free: '1 day', @@ -594,6 +596,28 @@ export const pricing: Pricing = { }, usage_based: false, }, + { + key: 'platform.logIngestion', + title: 'Log Ingestion', + plans: { + free: '1 GB included', + pro: ['20 GB included', 'then $0.50 per GB'], + team: ['20 GB included', 'then $0.50 per GB'], + enterprise: 'Custom', + }, + usage_based: true, + }, + { + key: 'platform.logQuery', + title: 'Log Query', + plans: { + free: '100 GB included', + pro: 'Log Ingestion Usage x 100', + team: 'Log Ingestion Usage x 100', + enterprise: 'Custom', + }, + usage_based: true, + }, { key: 'security.logDrain', title: 'Log Drain',