Skip to content

Status card

The Status card classifies entities with JMESPath expressions and shows category proportions plus counts grouped by an entity label.

When to use it

Use this card for a compact health or state summary when a small set of expressions can classify devices, interfaces, clients, or groups. Choose Status Overview instead when users need per-entity details and expandable Markdown descriptions.

Live example

The Card Lab supplies four static interface records to the production Status component and performs all JMESPath evaluation in the browser. No GraphQL request, authentication flow, or Neops backend is involved. Edit the mock data alongside the card configuration to test localCardFilter, entityLabelJmesPath, and mapping conditions against different records.

Open the Status Card Lab in a new page

Requirements

Requirement Value
Dashboard types Standard
Minimum size 3 columns by 2 rows
Data The selected entity collection from the current dashboard context
Backend capabilities Entity search for device, interface, client, or group in the normal application
Permissions Read access to the selected entity type and its fields used by JMESPath expressions

Configuration

The paths below are relative to cardConfig.data. The guided form exposes all fields except localCardFilter, which is available in expert JSON configuration.

entityType

Property Value
Type string
Required For live data
Default No default
Values device, interface, client, or group

Selects the entity collection the card subscribes to from the dashboard context. Expressions in localCardFilter, entityLabelJmesPath, and mapping[].jmesCondition evaluate against this collection or an array derived from it.

title

Property Value
Type string
Required No
Default Runtime fallback: no title provided
Values Plain text with optional {{ expression }} JMESPath interpolation

Sets the heading displayed above the status values. Title interpolation evaluates against the locally filtered entity array, so a title such as Interfaces ({{ length(@) }}) can include the current row count.

localCardFilter

Property Value
Type JMESPath expression
Required No
Default No filter
Values An expression that returns an entity array

Filters the card’s copy of the entity collection before labels, category counts, and title interpolation are evaluated. It does not change other cards on the dashboard.

When a valid filter removes every row from a non-empty source, the card shows a message naming the filter instead of the status visualization. If the expression is invalid, the card logs the error and continues with the unfiltered rows.

entityLabelJmesPath

Property Value
Type JMESPath expression
Required For label counts
Default No saved default. A missing value resolves to an invalid fallback expression and produces a zero-label message.
Values An expression evaluated against the filtered entity array

Selects the values shown in the card’s count list. The card groups equal results and displays the number of occurrences for each label.

For an interface array, [].state produces labels such as UP and DOWN. A scalar result is treated as a one-item list.

mapping

Property Value
Type array of mapping objects
Required For status proportions
Default No default. An empty mapping renders a single error segment and an empty legend.
Values Zero or more entries evaluated in array order

Defines the colored categories in the proportional meter and legend. Each entry is evaluated independently, so overlapping conditions count the same entity more than once. Array order controls segment and legend order, but it does not make categories mutually exclusive.

mapping[].type

Property Value
Type string
Required No
Default Runtime fallback: error
Values success, warn, error, info, or progress

Chooses the semantic state and color for this category. progress uses the yellow progress state and warn uses the orange warning state.

mapping[].jmesCondition

Property Value
Type JMESPath expression
Required No
Default Runtime fallback: @[*], which selects all filtered entities
Values An expression evaluated against the filtered entity array

Selects the entities counted in this category. An array result contributes its length; a non-array result contributes one. Categories with a zero count are omitted from the meter.

mapping[].description

Property Value
Type string
Required No
Default Runtime fallback: No description
Values Short user-facing category label

Labels this category in the information legend opened from the card. It does not control the entity label counts, which come from entityLabelJmesPath.

Examples

Interface health

{
  "cardId": "status",
  "data": {
    "title": "Interface health ({{ length(@) }})",
    "entityType": "interface",
    "entityLabelJmesPath": "[].state",
    "mapping": [
      {
        "type": "success",
        "description": "Up",
        "jmesCondition": "[?state == 'UP']"
      },
      {
        "type": "error",
        "description": "Down",
        "jmesCondition": "[?state == 'DOWN']"
      }
    ]
  }
}

This configuration groups interface labels by state and displays the proportion of up and down interfaces. States not selected by either mapping still appear in the label counts but do not contribute to the meter.

Ignore virtual interfaces

{
  "cardId": "status",
  "data": {
    "title": "Physical interface health",
    "entityType": "interface",
    "localCardFilter": "[?type != 'VIRTUAL']",
    "entityLabelJmesPath": "[].state",
    "mapping": [
      {
        "type": "success",
        "description": "Up",
        "jmesCondition": "[?state == 'UP']"
      },
      {
        "type": "error",
        "description": "Needs attention",
        "jmesCondition": "[?state != 'UP']"
      }
    ]
  }
}

This expert-mode configuration removes virtual interfaces only for this card before calculating labels and categories.

Behavior

The card reacts to entity data, loading state, errors, total count, and dashboard filters from its context. It shows a skeleton while data is loading or an error is present. The label list paginates inside smaller cards, and the number of visible columns adapts to the available width.

The proportional meter normalizes the non-zero mapping counts to percentages. Clicking the information control opens a legend using each mapping’s description and semantic color.

Limitations and safety

Overlapping mapping conditions can make totals exceed the number of source entities before normalization. Use mutually exclusive conditions when the meter should represent a partition of the data.

JMESPath expressions run in the browser against entity data the current user can already read. Avoid exposing sensitive field values in titles or labels on dashboards with a wider audience.

Use Markdown for narrative guidance and Status Overview when the reader needs individual entity details rather than only grouped counts.