chore/react-compiler-lints
12 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Eric Allam
|
4eb9292cbe |
feat(webapp,run-engine): queue metrics and health dashboard (#4131)
## Summary
Three related changes, each independently gated:
**Queue metrics and health.** Per-queue depth, throughput (enqueued,
started, completed), concurrency, whether a queue is throttled, and
scheduling delay (how long a run waits between becoming eligible and
actually starting), plus a per concurrency-key breakdown for keyed
queues. Collected from inside the run queue itself, stored in
ClickHouse, and surfaced on the Queues list, a new per-queue detail
page, the task pages, and the run inspector. The question it answers is
"does this queue have enough concurrency to keep up, and if not, which
key or which limit is the constraint".
**Percent-based queue concurrency limits.** A queue's concurrency
override can now be expressed as a percentage of the environment limit,
stored as the source of truth and re-materialized whenever the
environment limit changes. Absolute overrides above the environment
limit are now **rejected with a 400** instead of being silently capped,
which is a behavior change on `POST
/api/v1/queues/:queue/concurrency/override`.
**The `health` report.** A server-computed verdict on whether work is
flowing, whether the runs that do start are healthy, and whether
telemetry is fresh, rendered as text with sparklines. Available as `GET
/api/v1/reports/:key`, `trigger report`, and the `get_report` MCP tool
(plus a `report` MCP prompt, which shows up as a slash command in hosts
that support prompts).
With the flags off, the Queues page renders the pre-metrics component
verbatim, nothing is emitted, and nothing is written to ClickHouse.
## Configuration
Two independent gates, on purpose. Emission is global so data accrues
for everyone before anyone can look at it; the view is per organization
so it can be turned on for one org at a time without a deploy.
**Runtime flags (no restart)**
| Flag | Store | Gates |
| --- | --- | --- |
| `queue_metrics:enabled` | run-queue Redis key (`"1"`/`"0"`, off by
default) | All emission, gauges and counters. Cached in-process for 10s
with stale-while-revalidate, warmed eagerly at boot so the first op
after a deploy is not dropped. |
| `queue_metrics:gauge_sample_rate` | run-queue Redis key, `0..1` |
Fraction of queue ops that emit a gauge. Counters are never sampled, so
throughput stays exact at any rate. |
| `queueMetricsUiEnabled` | feature-flag catalog: global `FeatureFlag`
row, per-org `Organization.featureFlags` override wins | Whether an org
sees the metrics view at all: the Queues list variant, the queue detail
route, the built-in Queues dashboard, the concurrency-keys endpoint, and
the metrics blocks on task pages and the run inspector. Off by default;
a gated org gets a 404 on the detail route rather than an empty page. |
Both Redis keys are readable and writable from `/admin/queue-metrics`
(super-admin UI, with a live per-shard stream-health table) and
`GET`/`POST /admin/api/v1/queue-metrics` (admin PAT). The admin surface
uses its own Redis client, so it works on any instance regardless of
whether that instance runs the emitter or the consumer.
**Environment variables (boot time)**
| Variable | Default | Notes |
| --- | --- | --- |
| `QUEUE_METRICS_EMIT_ENABLED` | `0` | Constructs the emitter and
injects it into the run engine. Without it the run queue has no emitter
at all. |
| `QUEUE_METRICS_CONSUMER_ENABLED` | `0` | Boots the stream consumer on
this instance. Independent of emission, so consumers can be sized
separately from the API. |
| `QUEUE_METRICS_STREAM_SHARD_COUNT` | `4` | Stream shards, hashed per
queue. |
| `QUEUE_METRICS_CONSUMER_BATCH_SIZE` | `1000` | Poll batch equals
insert batch, so an ack can never outrun a write. |
| `QUEUE_METRICS_REDIS_{HOST,PORT,USERNAME,PASSWORD,TLS_DISABLED}` |
falls back to the run-queue Redis | Set `HOST` to move the metrics
stream onto a dedicated instance so a metrics backlog cannot compete
with the run queue for memory. Self-hosters can leave it unset and get a
single-Redis deployment. |
| `QUEUE_METRICS_COUNTER_STREAM_MAXLEN` | `2000000` shared, `8000000`
dedicated | Bound on how much a stalled consumer can hold. The default
is deliberately lower when the stream shares the queue-critical Redis. |
| `QUEUE_METRICS_COUNTER_ODOMETER_TTL_SECONDS` | `604800` | TTL on the
per-queue cumulative counter key, refreshed on every write, so only
queues idle for the whole window are purged. |
| `QUEUE_METRICS_MAX_QUEUE_NAMES_PER_ENV` | `1000` | Distinct queue
names tracked per environment; overflow collapses into `__overflow__`. |
| `QUEUE_METRICS_MAX_CONCURRENCY_KEYS_PER_QUEUE` | `10000` | Same idea
one level down, per queue. |
| `QUEUE_METRICS_GAUGE_SAMPLE_RATE` | `1` | Default for the live
sample-rate key above. |
| `QUEUE_METRICS_QUERY_TABLES_VISIBLE` | `0` | Lists the queue-metrics
tables in the Query page, its schema docs, the schema API and the AI
query context. Off keeps them unlisted while the feature is dark; a
query naming them still runs either way. |
| `QUEUE_METRICS_CLICKHOUSE_URL` | falls back to the shared wiring |
Runs queue metrics on their own ClickHouse service: the consumer's
inserts and every queue-metrics read go through it, so a metrics-heavy
chart refresh never competes with runs-list or trace reads. Unset
reproduces the previous split exactly (inserts on `CLICKHOUSE_URL`,
reads on the query pool). |
| `QUEUE_METRICS_CLICKHOUSE_READER_URL` | the write URL | Reader split,
so the consumer's inserts can never land on a read endpoint. |
|
`QUEUE_METRICS_CLICKHOUSE_{KEEP_ALIVE_ENABLED,KEEP_ALIVE_IDLE_SOCKET_TTL_MS,MAX_OPEN_CONNECTIONS,LOG_LEVEL,COMPRESSION_REQUEST}`
| `1`, unset, `10`, `info`, `1` | Pool tuning, matching the other
per-workload ClickHouse clients. |
Migrations to apply: ClickHouse `036_create_queue_metrics_v1.sql`, and a
Postgres migration adding the nullable
`TaskQueue.concurrencyLimitOverridePercent`. Both are additive.
## How collection works
Queue operations produce two kinds of signal, and they have opposite
failure modes, so they are handled differently.
**Gauges** (queued, running, queue limit, env queued, env running, env
limit, throttled, plus keys-with-backlog and worst-key wait on keyed
queues) are read *inside* the same Redis script that performs the
enqueue or dequeue, so the reading is atomic with the operation it
describes rather than a racy follow-up read. The script returns them on
its reply and the app forwards them to the stream. Gauges are sampled
and drop-tolerant: they are aggregated with `max`, so a lost reading
costs resolution, never correctness.
**Counters** (enqueued, started, completed, plus nack and dead-lettered)
are cumulative odometers. Each event increments a per-queue key on the
metrics Redis and emits the absolute total, and ClickHouse takes the
difference across buckets at read time. This is the important property
of the design: a summed-delta counter undercounts permanently on any
lost event, while a cumulative one self-heals, because the next
surviving reading restates the whole total. Only bucket granularity can
be lost, never the total. A queue returning after its odometer TTL
expired restarts at 1 and reset detection handles it, which is safe
precisely because expiry only spans a window with no activity.
Both land on one sharded Redis stream. A consumer reads it with a
consumer group, reclaims stale pending entries on a 15s interval rather
than on every poll, maps one entry to one or two ClickHouse rows
(whole-queue and, for keyed queues, per-key), and acks only after the
insert lands. Each batch carries a dedup token derived from its
stream-entry ids, and the target tables set
`non_replicated_deduplication_window`, so a retried batch cannot
double-count either the raw rows or the aggregates that hang off them.
Consumer and emitter both emit OTel metrics
(`queue_metrics.emitter.emitted`,
`queue_metrics.consumer.{entries,rows_inserted,insert_errors,insert_duration,stream_depth,group_lag,pending,lag_unknown}`);
stream depth and group lag are the two worth alerting on, and
`lag_unknown` exists because Redis can report a null lag after a trim,
which must not be read as zero.
## Storage and read path
`queue_metrics_raw_v1` is a short landing table with a 6 hour TTL. Four
aggregate tiers are materialized straight from raw, never cascaded off
each other, each with a 30 day TTL:
- `queue_metrics_v1`, 10 second buckets per queue, the default read path
- `queue_metrics_5m_v1`, 5 minute buckets per queue, for wide ranges and
cross-queue ranking
- `env_metrics_v1`, 10 second buckets per environment, queue-independent
so it stays cheap at any range
- `queue_metrics_ck_v1`, 10 second buckets per concurrency key
Every tier is an MV from raw because the counter states do not survive a
cascade: their merge is order sensitive, so a `-MergeState` chain off
the 10s table inflates the result, and the same property means an
aggregate state may only be merged inside one queue. That constraint is
now enforced by the query engine rather than by reviewer discipline: a
column can declare a `mergeGroupKey`, and any query that references it
without grouping by, or pinning to a single value of, every named key
fails to compile with an actionable message.
On the read side, TRQL gains three tables (`queue_metrics`,
`env_metrics`, and a `queue_metrics_by_key` that is hidden from the
editor, schema docs and schema API but still queryable, so per-key rows
can never silently merge into a plain per-queue query), plus
`deltaSumTimestampMerge` and `quantilesTDigestMerge`. Two schema-level
optimizations ride along: a table can declare coarser rollups, so a
query whose bucket interval is 5 minutes or wider is routed to the 5m
table with no change to the query itself, and it can opt into the
ClickHouse query cache with time bounds floored to a fixed grid, so the
auto-refreshing dashboards actually share cache entries instead of
missing on every tick. Both are caller-side substitutions, so the
printer stays unaware of physical layout.
All of this can also live on its own ClickHouse service. A table
declares the pool its reads run on, the three queue-metrics tables name
the dedicated one, and the ingestion consumer writes through the same
client, so both directions move together with one env var and nothing
else routes differently.
The other engine change is opt-in gap filling: charts can request rows
for empty buckets, where counters zero-fill and gauges carry forward.
Grouped gauge series are densified per group and carried inside a
partition, so a quiet queue's line holds its last value without bleeding
another queue's value into it.
## Queue concurrency limits
`concurrencyLimitOverridePercent` on `TaskQueue` is the source of truth
when an override is set as a percentage; the absolute `concurrencyLimit`
is materialized from it (floored, clamped to at least 1 so a percentage
can never act as a pause, and never above the environment limit). Every
path that changes an environment limit now recalculates the
environment's percent-based overrides afterwards, outside the
transaction, and pushes changed limits to the engine. The push is
attempted even when the stored value did not change, so a previously
failed sync self-heals rather than leaving the database and the engine
diverged; paused queues are skipped so a recalculation cannot
effectively unpause one.
The API accepts exactly one of `concurrencyLimit` or `percent`, and the
reject-instead-of-clamp change above means a request asking for more
than the environment allows now fails loudly. The percent bound (greater
than 0, at most 100) is defined once and shared by the zod schema, the
dashboard mutation handler and the service, so the three cannot drift.
The concurrency-keys table on a queue is now paginated against the
ClickHouse per-key tier, ranked by peak backlog with the total on every
row from a single scan, and only the keys on the current page are
enriched with live counts from Redis. That replaces a hard top-50 cap
with something whose cost is a function of page size rather than key
cardinality.
## The health report
`GET /api/v1/reports/:key?period=&format=markdown|ansi|json`. The
verdict is computed on the server and is deterministic, not
model-generated. Three independent analyzers run over one input
snapshot: flow (is work moving, and if not, is the cause a limit,
throttling, one bad queue, or dead-lettering), execution (are the runs
that start succeeding, and at what latency), and liveness (how fresh is
the telemetry). When telemetry is genuinely stale, the first two are
forced to unknown and every actionable field is stripped, so no surface
ever advises action off stale data.
Authorization is per query table rather than a blanket query grant: a
JWT must be scoped to every table the report reads (`runs`,
`env_metrics`, `queue_metrics`), so a narrowly scoped token cannot pull
a report that reads more than it was granted. `period` is validated as a
shorthand with a 90 day ceiling at the edge. The report catalog is a
registry of `{ load, interpret }` entries, so the next report is a new
entry and no change to the route, the view model, the renderers, the CLI
or the MCP tool.
`trigger mcp` no longer launches the install wizard when stdout is a
TTY, which fixed a real failure: hosts spawn the server over a PTY, so
the wizard would open and the client would time out waiting for a server
that never started. The wizard now needs `trigger mcp --install`.
## The part that is live regardless of every flag
The enqueue and dequeue scripts now return a 2-tuple so a gauge reading
can ride back on the reply. Every return site in the eight affected
scripts is wrapped, and a `nil` original is converted to `false` on the
way out, because a raw `nil` in the first slot would make Lua truncate
the multi-bulk reply and silently drop the gauge on the throttled and
empty-queue paths. The reply shape and the destructuring on the app side
are exercised on every queue operation whether or not metrics are
enabled, so that is the part of `run-engine` worth the closest review.
One behavior fix in the same area: the scheduling-delay anchor is set
only on a run's first entry into the queue. Anchoring it to trigger time
on re-enqueues made waitpoint and checkpoint resumes report the entire
wait as scheduling delay. Queue ordering is untouched, so a re-enqueued
run keeps its position, and nacks deliberately keep the original anchor
because a rolled-back dequeue is the same continuous wait.
A pending-version promotion still anchors to trigger time, on purpose:
that promotion is the run's first real entry into the queue, since the
trigger deliberately held it back waiting for a worker version, and the
TTL is armed at the same point for the same reason. The consequence is
worth naming, because it is a judgement call: a run that waits on a
deployment reports that wait as scheduling delay on its queue, which is
time unrelated to queue capacity.
## Verification
Unit and integration suites across the new package, the run queue, the
mapping layer, the query engine and ClickHouse (including a test that
applies migration 036 through the same splitter CI uses, and a
regression test that inserts the same batch three times to prove the
aggregates do not inflate). Beyond that, the whole path was driven end
to end against a live stack with real runs: emitter to Redis stream to
consumer to ClickHouse to the dashboards, for both the local dev path
and the deployed path where a supervisor drives the dequeue, with
assertions on exact counter reconstruction per queue and per concurrency
key, throttling, environment saturation, scheduling delay, and a
deliberate mid-stream reading drop to confirm the cumulative counters
still reconstruct the correct total. The gated-off state was checked on
every touched surface.
The dedicated ClickHouse service was verified against a second,
separately-schema'd instance: with it configured, the driven counters
reconstruct exactly on the dedicated instance, the shared instance gains
no rows for that window, a read through the query API returns the value
that exists only on the dedicated instance, and a `runs` query still
succeeds (it would fail outright if it were mis-routed to a service
without that table). With the variable unset, the full suite passes
unchanged.
---------
Co-authored-by: Katia Bulatova <katia@trigger.dev>
Co-authored-by: Katia Bulatova <katherine.bulatova@gmail.com>
Co-authored-by: James Ritchie <james@trigger.dev>
|
||
|
Oskar Otwinowski
|
efe24f9c2a |
feat(private-link): Add private links UI (#3264)
⚒️ Publish Worker (v4) / build (supervisor) (push) Has been cancelled
|
||
|
nicktrn
|
e7795a06ad |
Fix: fixes and prerequisites for v4 self-hosting (#2150)
* remove pgadmin * remove V3_ENABLED * v3 is always enabled * enfore docker machine presets by default * rename autoremove env var * prefix more k8s-specific env vars * same prefix for all docker settings * improve profile switcher copy * supervisor can load token from file * optional webapp worker group bootstrap * fix error message * fix app origin fallback for otlp endpoint * use pnpm cache for webapp docker builds * increase default org and env concurrency limit to 100 * optional machine preset overrides * improve s3 pre-signing errors * fix DOCKER_ENFORCE_MACHINE_PRESETS bool coercion * shard unit tests * fix for s3-compatible services * optional object store region * Update apps/supervisor/src/workerToken.ts Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * fix DEPLOY_REGISTRY_HOST example * fix platform mock * remove remaining v3Enabled refs * fix error type.. bad bot --------- Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> |
||
|
Willow (GHOST)
|
54017cbffa | feat: always show alerts tab and lock email alerts when keys are missing (#1478) | ||
|
nicktrn
|
35dbaedf69 |
v3: self-hosting (#1147)
* add amin email regex env var * fix displayed init command for self-hosted setups * shared env var to disable telemetry in cli and webapp * pin sdk version during init * if specified, add api url to dev command shown after init * improve checkpoint support detection * control forced checkpoint simulation via env var * add public init to providers * better checkpoint support check for coordinator * add docker to coordinator image * update docker provider containerfile * bump remaining containers to node 20 * add infra image build to default publish workflow * lockfile * remove concurrency group from infra workflow * add docker provider to build matrix * fix var subst * checkpoint test is docker specific * enable v3 projects by default on self-hosted instances * fix v3 setup command again * add default posthog key * self-hosting docs * add latest tags to versioned infra and webapp builds * some checkpoint errors should skip retrying * add changeset * shorten paragraph * some docs updates * update tunnelling section * add registry setup section * use correct cli push flag * add checkout to v3 branch * update the worker machine setup steps * fix infra build * small docs update * remove unused feature function * Revert "remove unused feature function" This reverts commit cfe07887a12b6893dca8ce499964481a9b3dc9db. * fix self-hosted v3 feature gate * add note about missing arm support * simplify helper script syntax |
||
|
James Ritchie
|
89eaef495f |
New alerts platform status + Alerts docs (#1098)
* debug tooltip now scrolls * Added a link to subscribe to alerts and improved the project alerts blank state * Better external link icon * Docs: Removed webhook tasks * Docs: removed limits performance * Docs: removed FAQs * Docs: Removed Architecture section * Docs: Removed API reference: CLI * Docs: Removed API reference: Objects * Docs: Removed API reference: Functions * Docs: removed automated tests * Docs: removed Middleware * Docs: removed Using APIs * Docs: removed Rollbacks * Docs: removed Trigger Filters * Docs: removed Webhook Tasks * Docs: removed Zod Tasks * Docs: Renamed Community page * Docs: Added a new Troubleshooting section and Alerts docs page * Hide the New Alerts button again if list is greater than 10 items * Customers now have to contact us for Slack Connect Support. * Fix the alerts docs link * Added env vars for a different alert email address, and whether the feature is enabled or not * Only show the alerts sidemenu item if the feature is enabled * Use a separate email client for sending alerts * Removed the link to Context from v3 docs * Removed obvious docs links that are now missing pages --------- Co-authored-by: Matt Aitken <matt@mattaitken.com> |
||
|
Matt Aitken
|
584936fa29 |
Early v3 project UI (#904)
* Added ProjectVersion to projects, defaults to V2 * Moved v3Enabled to the existing feature flags * Update to using the v3Enabled feature flag * Allow people to choose v3 when creating a new project * Added version to the ProjectPresenter * v2 project and v3 project redirecting * .env.example for the v3-catalog * Added sdkVersion and cliVersion columns to the BackgroundWorker table * Added additional classes for environments * First draft of the Tasks table * Link to the task page * V3 side menu project items * Moved the ListPagination component into the components folder * Moved the TaskListPresenter to a v3 folder * Bare bones task page with tabs * Task page, we’re going to delete this though * Bare bones runs table working * Rejigged the columns * The run table status * Environment and status filtering working * Added time filters * Cursor and direction is working… I think it’s tricky to know for sure * Added TaskRun numbers * Selecting a task now links to the runs page with filters turned on * Added support for the enqueued status * Reworked the task table * Link to the task and environment runs * The run page is rendering a tree of the events * Change the task table column to “Created at" * WIP on making the run tree view look good * Improvements to the run tree * Removed the janky scroll bar flash * Change the title of the task logs to just the task ID * Live timer when a span is running * Added “Show parent items” link * Fixed the bug jumping to parent items * Style improvements to the run * Added the resizable handle to the run page * Moved formatDuration to core/v3 * Wait for now has nice log messages * The run detail panel is working with just a title for now * Navigating to a span and persisting between page reloads is working * The run detail timeline * Wrap log dates in a paragraph * Latest span detail view * Scrolling in the right-hand panel * Tweak default resizable layout for the run page * Attempted improvements to stop a recursive issue on TreeView * TreeView useReducer WIP * Changed the change callback * Add changes to the state * Use the new onSelectedIdChanged in the app * Don’t update the state from the outside * Filtering fix, although navigation doesn’t work nicely * Filtering working when changing the content and clearing it * Don’t allow the same selectedId callback to be called twice… * useDebounce hook * Switch from using defer to just typedjson for now * Latest attempt at span navigation * Removed log * Turn off filtering for now, it’s causing the Links to break somehow * Fix for page height issue * Added (Developer Preview) to the v3 project select box * Revert "Filtering working when changing the content and clearing it" This reverts commit 20d9fbe36ded619e9d3eb0b23d4ed0568a88a615. # Conflicts: # apps/webapp/app/components/primitives/TreeView/TreeView.tsx * Switch to using the old filtering * Added useThrottle hook * Instantly close the panel when deselecting a node, use debounce when navigating to a span * Better spacing in the right hand panel * Comment out the v3 side menu pages that don’t exist yet * Fix for typecheck fail * Clear the statuses too |
||
|
Matt Aitken
|
4bd1786ae5 |
Billing (#789)
* Initial commit - started work on new billing components * Added a slider component * Added features to the pricing tiers * Small pricing tier margin tweaks * WIP on a concurrecy chart * Reworked the pricing tiers to include a segmented controller and tooltips * Renamed the charts storybook page * Made the way data is added more flexible and added some definition tool tips * Term definitions are used properly in the tiers * Callouts can now have an optional CTA on the right hand side * Alignment fix for the callouts * organize imports * Definition tooltip now its own component * renamed the storybook story * WIP new volume discount table and usage sliders * Added pricing calculator sliders * Fixed alignment of the legend * Breadcrumb now has an upgrade prompt and button * New Join our Slack button in the side menu * New progress meter in the side menu * Use the highest of 2 values to show progress * An attempt to fix the step count in the calculator slider * WIP usage progress bar * Added the 4 progress bars * More examples of the usage bar * Better way to include the percentage in the free plan progress meter * The usage bar now works with the extra runs over the free limit * Pricing calculator has better slider logic * Moved the free plan usage bar into it’s own component and added it to storybook * Usage bar chart now supports a paying customer option and optional billing limit. Also added more usage examples to storybook * Added more examples of usage to storybook * tooltip takes classname * Format numbers nicely * Added a tooltip to show the precise numbers in the chart * small improvements to the billing calculator * New onboarding choose plan page * pricing tiers better fill the size of their container * Removed unused code * Usage bars animate * Wording tweak * Callouts fit the button size better * Added new routes for the 2 new billing pages * import cleanup * Added meta info in the header for bill price, plan type and billing period * made free a noun * Added pricing calculator to the plans page * Fixed some illegal markup when using tooltips * Added container query support * Added new concurrency chart to the usage page * billing now has a green theme * Simplified the plan summary info int the header * Fixed padding alignment * Use a custom lable for the concurrent runs chart * Removed the Job runs table * Latest lockfile * Show a message if you haven’t done runs yet * Added a layoutId to the pageTabs * Show a message callout if you’ve exceeeded 10k runs on the free plan * Added a callout on the plans page if you’re over the runs limit * Fixed button inside button bug * Removed the background gradients from the app * The billing package is importing properly * Getting the curent plan for an org * Reading the current plan and usage * Hooked up the free plan bar * Render basic billing details * vol discount table has optional values * Added a new page to show new subscribers * Created a new hook for confetti on the subscribed page * Toast styling updated * The Invoice and Manage card details links are working * Meta appEnv data optional * Data for the plans page * Format the billing period duration in days * Switch to 20 icons * URL for the subscribed page now includes the org path * New pathBuilder path for the subscribed page * Plans are upgraded/downgraded successfully * Fixed badly named paths * Improved some of the display * Deal with when the user has canceled so they can re-upgrade * Subscribing from Stripe is working, and canceling * Tidied up some bits, latest billing package * The tiers are now rendering using the real data * The onboarding screen is hooked up, but not linked to yet * Onboarding price selection working * Pricing slider working * Price estimation working * Pricing calculator working on the select a plan page * Button copy change * Improved the layout of the run calculator marker * Fix for the period end when you’ve canceled * Improved the formatting in the calculator * Pricing table tooltip uses the vol discount pricing table * Remove the vertical lines from the calculator * Contact us button in Enterprise tier opens the contact us form * Added composite index to triggerdotdev_events.run_executions for event_time and organization_id * Concurrent run chart data * Improves styling, fix for React error with Enterprise contact button * Show warning box when you’ve hit the concurrency in the past 30 days * Lots of work o the usage page * Improvements to the usage page * Show 31 days of data, fix for not showing the current date… * Stripe portal links are generated when the user clicks through * Better alignment of the reference line and x-axis label * Readme update * Fixed pricing button loading buttons * Show warnings about concurrency and runs on the plans page * Removed some storybook stories * Join Slack channel shows if you’re subscribed with instructions * Added a gap between the runs charts * Improved the definitions * Added some margin to the page loading spinner * A wider, cleaner feedback panel * Modal backgrounds match the Sheet style * Fixed menu item text being clipped * Improved icons for execution time and exclusion count * Concurrency chart now renders the dates nicely * Fix for plans data on the plans page * The healthcheck doesn’t need to do a HEAD request to / * Better disabled states and fixed the disabled hover state issue * Improved the segmented controller style * loading spinner now centered inside the button * Redirect to the project page when selecting the free plan * Fix for “Runs” and added real date to upgrade warning * DeCAPITALIZED some things --------- Co-authored-by: James Ritchie <james@jamesritchie.co.uk> |
||
|
Eric Allam
|
20ed4e22ef | Implement the cloud private beta invite form | ||
|
Eric Allam
|
4d316c5524 | Fixed the OAuth2 callback urls by constructing URL using x-forwarded-proto header | ||
|
Eric Allam
|
ed65ba4a73 | isManagedCloud should be true when in the test cloud | ||
|
Eric Allam
|
40ffde33b6 | Add isManagedCloud feature, remove sentry, and require custom oauth app on self-hosting |