PlatformMonitor

Observability & Metrics

With hundreds to thousands of events going through your Inngest Apps, triggering multiple Function runs, getting a clear view of what is happening at any time is crucial.

The Inngest Platform provides observability features for both Events and Function runs, coupled with Event logs and a detailed Function Run Logs to inspect arguments and steps timings.

Function runs observability

The Functions list page provides the first round of essential information in one place with:

  • Triggers: Events or Cron schedule
  • Failure rate: enabling you to quickly identify a surge of errors
  • Volume: helping in identifying possible drops in processing

The Functions list page lists all available Functions with essential information such as associated Events, Failure rate and Volume.

Navigating to a Function displays an overview composed of three main parts:

  1. KPIs - on the top
  2. Metrics - at the center
  3. Configuration - on the right

Clicking on a Function leads us to the Function view, composed of three main parts, KPIs, metrics (as charts) and Configuration information.

Function KPIs

The Function KPIs are composed of two essential numbers for the selected time range (default to 24h):

  • Volume: the number of Function runs
  • Failure rate: the number of Functions runs that failed after reaching their maximum retry policy

The KPIs are composed of two metrics: the Volume and the Failure rate.

Those two numbers are a good representation of the state of your application that might indicate some actions to take:

  • A sudden Volume increase might require updating your Function configuration (ex: Throttling)
  • A Volume at zero might suggest that some events stopped from being sent
  • A high failure rate might be linked to a recent deployment or an external outage

Function Metrics

The Function overview page showcases many charts featuring metrics that can help you better understand the overall performance of your Inngest Functions.

Function Runs

The Function Runs chat is a bar chat where each bar represents a variable time bucket and each bar's stack a function status (failed, succeed or cancelled).

The Function Runs charts provide a snapshot of the number of finished Function runs in buckets (from 1 minute to 1 hour).

How to use this chart?

You can leverage this chart to identify a possible recurrence or surge in failures or cancellations that might have affected the total volume for the active time range.

Function Throughput

The Function Throughput is a line chart featuring 3 series: queued, started and ended Function runs.

The Function Throughput chart shows the rate of which new function runs are queued, started and ended with flow control in mind. This shows the performance of the system of how fast new runs are created and are being handled.

How to use this chart?

Flow control might intentionally limit throughput, this chart is a great way to visualize how flow control may be able to limit throughput.

Step Running & Step Backlog - Point in Time

The Step Running is a line chart featuring two series: queues and sleeping steps. The Step Backlog is a line chart featuring a single series: running steps and some colored bar indicating concurrency capacity exhaust events.

Both charts represents Step activity at a given point in time. Unlike other charts present on this page, these charts are not aggregating the number of running or started steps in a given time bucket.

How to use these charts?

The Step Backlog and Step Running charts are helpful to assess the configuration of your Inngest Functions.

For example, a low Function Throughput might be linked to a high number of concurrent steps combined with a restrictive concurrency configuration.

SDK Request Throughput

The SDK Request Throughput is a line chart featuring three series: queued, started and ended Function runs.

This charts indicates the throughput at which SDK requests (or steps) are queued and executed.

How to use this chart?

This chart is a useful tool to evaluate in the requests sent by the Inngest Platform matches the number of steps created by Functions runs.

The SDK Request Throughput is also useful to evaluate the number of requests sent to your application over time.

Function RateLimit

The Function RateLimit chart indicates occurrences where the Flow Control Rate Limit mechanism had to prevent Function runs.

How to use this chart?

This chart is useful to assess the overall Rate Limit rate of an Inngest Function. For example, a lack of data might indicate that this Inngest Function might not require Rate limiting.

Function Configuration

The Function Configuration right panel is meant to be used as a reference for the KPIs and Function Metrics. This panel features information on the retries policy and Flow Control configuration.

Updating your Function's retry configuration can solve a high failure rate. Also, increasing your Function's concurrency can help deal with Function Throughput issues.

The Function Configuration side section features the retries and concurrency information.

Events observability

Events volume and which functions they trigger can become hard to visualize.

Thankfully, the Events page gives you a quick overview of the volume of Events being sent to your Inngest account:

The Events page lists the available Event type. Each list item features the event name along with its associated Functions and a events volume indicator.

Get more detailed metrics for a dedicated event by navigating to it from the list:

Event Metrics and Logs

The Event page helps quickly visualize the throughput (the rate of event over time) and functions associated with this event.

The event occurrences feature a “Source” column, which is helpful when an event is triggered from multiple Apps (ex, using different languages):

Clicking on an Events leads us to the Event page that displays, at the top, a chart of events occurrences over the last 24 hours and at the list of associated events.

Clicking on a specific event will redirect you to its Logs.

The Event Logs view provides the most precise information, with the linked Function run and raw event data.

Such information, combined with the ability to forward the event to your Local Dev Server instance, makes debugging events much quicker:

Clicking on an event of the below list open the Event Logs view, providing much detailed information such as the Event Payload and triggered Functions.