# @rootly/backstage-plugin

> [![npm version](https://badge.fury.io/js/@rootly%2Fbackstage-plugin.svg)](https://badge.fury.io/js/@rootly%2Fbackstage-plugin) [![License](https://img.shields.io/badge/license-MIT-blue)](https://opensource.org/licenses/MIT)

Latest version **1.4.0** (published 2026-10-11) · MIT license · 0 weekly downloads

## Install

```sh
npm install @rootly/backstage-plugin
pnpm add @rootly/backstage-plugin
yarn add @rootly/backstage-plugin
bun add @rootly/backstage-plugin
```

## Health

**Score 75/100 (B)** — status: active.

Positive: has types; esm support; no vulnerabilities; has provenance; recently updated; high maintenance score; high quality score.

Warnings: low downloads.

## Facts

| | |
|---|---|
| Version | 1.4.0 |
| Published | 2026-10-11 |
| First published | 2022-07-02 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | ESM + CommonJS |
| Dependencies | 18 |
| Unpacked size | 366.7 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Provenance | attested (GitHub Actions) |
| GitHub stars | 11 |
| Maintainers | alex-rootly, quentin-rootly |
| Keywords | backstage, plugin, rootly |

## Links

- npm: https://www.npmjs.com/package/@rootly/backstage-plugin
- Repository: https://github.com/rootlyhq/backstage-plugin
- Issues: https://github.com/rootlyhq/backstage-plugin/issues
- npm.io page: https://npm.io/package/@rootly/backstage-plugin

## Dependencies (18)

- [moment](https://npm.io/package/moment.md) ^2.31.0
- [chart.js](https://npm.io/package/chart.js.md) ^4.5.1
- [chartkick](https://npm.io/package/chartkick.md) ^5.0.1
- [react-use](https://npm.io/package/react-use.md) ^17.6.1
- [contrast-color](https://npm.io/package/contrast-color.md) ^1.0.1
- [react-chartkick](https://npm.io/package/react-chartkick.md) ^0.5.4
- [@backstage/theme](https://npm.io/package/@backstage/theme.md) ^0.7.3
- [@material-ui/lab](https://npm.io/package/@material-ui/lab.md) 4.0.0-alpha.61
- [@material-ui/core](https://npm.io/package/@material-ui/core.md) ^4.12.4
- [@material-ui/icons](https://npm.io/package/@material-ui/icons.md) ^4.11.3
- [@backstage/catalog-model](https://npm.io/package/@backstage/catalog-model.md) ^1.10.1
- [@backstage/core-compat-api](https://npm.io/package/@backstage/core-compat-api.md) ^0.5.15
- [@backstage/core-components](https://npm.io/package/@backstage/core-components.md) ^0.18.14
- [@backstage/core-plugin-api](https://npm.io/package/@backstage/core-plugin-api.md) ^1.12.10
- [@backstage/frontend-plugin-api](https://npm.io/package/@backstage/frontend-plugin-api.md) ^0.18.1
- [@backstage/plugin-search-react](https://npm.io/package/@backstage/plugin-search-react.md) ^1.11.8
- [@backstage/plugin-catalog-react](https://npm.io/package/@backstage/plugin-catalog-react.md) ^3.2.3
- [@rootly/backstage-plugin-common](https://npm.io/package/@rootly/backstage-plugin-common.md) ^1.6.0

## Recent versions

- 1.4.0 (latest) — 2026-10-11
- 1.3.3 — 2026-08-19
- 1.3.2 — 2026-08-19
- 1.3.1 — 2026-07-30
- 1.3.0 — 2026-05-01
- 1.2.2 — 2025-10-17
- 1.2.1 — 2025-10-15
- 1.2.0 — 2025-10-08
- 1.1.0 — 2025-10-08
- 1.0.0 — 2025-06-11
- 1.0.0-beta.14 — 2024-11-28
- 1.0.0-beta.13 — 2024-11-27
- 1.0.0-beta.12 — 2024-11-19
- 1.0.0-beta.11 — 2024-11-01
- 1.0.0-beta.10 — 2024-10-26
- … 23 more at https://npm.io/package/@rootly/backstage-plugin/versions

## README

# Rootly plugin for Backstage

[![npm version](https://badge.fury.io/js/@rootly%2Fbackstage-plugin.svg)](https://badge.fury.io/js/@rootly%2Fbackstage-plugin)
[![License](https://img.shields.io/badge/license-MIT-blue)](https://opensource.org/licenses/MIT)

The Rootly plugin is a frontend plugin that displays Rootly services, incidents in Backstage. The plugin includes three components that can be integrated into Backstage:

- The `RootlyPage` routable extension component which produces a standalone page with the following capabilities:

  - View and search a list of entities
  - View and search a list of services
  - View and search a list of functionalities
  - View and search a list of teams
  - View and search a list of incidents
  - View and search a list of catalog entities (with catalog selector)

- The `RootlyOverviewCard` component which produces a summary of your entity with incidents over last 30 days and ongoing incidents. Also supports catalog entities with name, description, and properties display.

- The `RootlyIncidentsPage` component which produces a dedicated page within your entity with details about ongoing and past incidents.

You can link and import entities in rootly services, functionalities, teams, and catalog entities through Backstage Web UI or through annotations.

## Installation

### Creating an Rootly API key

Because of the features provided by the plugin, an API key with full access to your Rootly domain is required.

- Read access on services is needed to list services, write access to link entities to services.
- Read access on functionalities is needed to list functionalities, write access to link entities to functionalities.
- Read access on incidents needed to list incidents.

1. Go to `Profile` -> `Manage API Keys`.

2. Click on `Generate New API Key` button.

3. Copy the key.

   ![Creating Api Key](./docs/rootly-creating-api-key.png)

### Backstage Setup

Add the plugin to your frontend app:

```bash
yarn add --cwd packages/app @rootly/backstage-plugin
```

Add the plugin to your backend app:

```bash
yarn add --cwd packages/backend @rootly/backstage-plugin-entity-processor
```

Configure the plugin in `app-config.yaml`. The proxy endpoint described below will allow the frontend
to authenticate with Rootly without exposing your API key to users.

```yaml
# app-config.yaml

# Rootly single-organization configuration example
rootly:
  rootly-main:
    proxyPath: /rootly/api

# Rootly multi-organizations example
rootly:
  rootly-main:
    isDefault: true
    proxyPath: /rootly/api
  rootly-sandbox:
    proxyPath: /rootly-sandbox/api
    showTestIncidents: true # optional, see "Test incidents" below

...

proxy:
  endpoints:
    '/rootly/api':
      target: 'https://api.rootly.com'
      headers:
        Authorization: Bearer ${ROOTLY_MAIN_TOKEN}
    '/rootly-sandbox/api':
      target: 'https://api.rootly.com'
      headers:
        Authorization: Bearer ${ROOTLY_SANDBOX_TOKEN}
```

#### Configuration options

Each entry under `rootly` accepts:

| Option              | Description                                                                                                                                        |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `proxyPath`         | Backstage proxy path that forwards to the Rootly API.                                                                                              |
| `isDefault`         | Organization used when a component does not pass `organizationId`. Defaults to the first entry.                                                    |
| `apiHost`           | Rootly web host used to build links (for example `https://rootly.com`).                                                                            |
| `showTestIncidents` | Include test incidents (kind `test` / `test_sub`) in incident tables by default. Defaults to `false`, so test incidents are hidden unless enabled. |

#### Test incidents

Incident tables hide test incidents by default by sending
`filter[kind][not_in]=test,test_sub` to the Rootly API. Set
`showTestIncidents: true` on an organization (for example a sandbox account) to
list them by default. Users can still flip the **Show test incidents** toggle in
the incidents table filter bar.

### Annotations

Available annotations are the following:

```yaml
rootly.com/organization-id: rootly # Optional if you use Rootly multi organizations.
rootly.com/service-id: 7a328a08-6701-445e-a1ad-ca2fb913ed1e # Use service-id or service-slug. Not both.
rootly.com/service-name: ElastiSearch Staging
rootly.com/service-slug: elasticsearch-staging # Use service-id or service-slug. Not both.
rootly.com/service-auto-import: enabled # This will auto import the entity as a rootly service if we don't find any.
rootly.com/functionality-id: 7a328a08-694f4e1b-abbc-4cf7-bba0-a403df30ed88 # Use functionality-id or functionality-slug. Not both.
rootly.com/functionality-name: Login
rootly.com/functionality-slug: login # Use functionality-id or functionality-slug. Not both.
rootly.com/functionality-auto-import: enabled # This will auto import the entity as a rootly functionality if we don't find any.
rootly.com/team-id: 39e77dcc-e056-4849-9dda-a362b2413e5c # Use team-id or team-slug. Not both.
rootly.com/team-slug: infrastucture # Use team-id or team-slug. Not both.
rootly.com/team-name: Infrastucture
rootly.com/team-auto-import: enabled # This will auto import the entity as a rootly team if we don't find any.
rootly.com/catalog-entity-id: 7a328a08-6701-445e-a1ad-ca2fb913ed1e # Use catalog-entity-id or catalog-entity-slug. Not both.
rootly.com/catalog-entity-name: Enterprise
rootly.com/catalog-entity-slug: enterprise-tier # Use catalog-entity-id or catalog-entity-slug. Not both.
rootly.com/catalog-entity-auto-import: enabled # This will auto import the entity as a rootly catalog entity if we don't find any.
rootly.com/catalog-id: 7a328a08-6701-445e-a1ad-ca2fb913ed1e # Required for auto-import. The catalog to create the entity in.
rootly.com/catalog-slug: customer-tier # Alternative to catalog-id. The catalog slug to find or create.
rootly.com/catalog-description: Customer pricing tiers # Optional. Description for the catalog when auto-creating.
```

#### Attribute pass-through annotations

You can set any Rootly API attribute on services, functionalities, teams, and catalog entities using the `attr` prefix:

```yaml
rootly.com/service-attr-<api_attribute>: "value"
rootly.com/functionality-attr-<api_attribute>: "value"
rootly.com/team-attr-<api_attribute>: "value"
rootly.com/catalog-entity-attr-<api_attribute>: "value"
```

Value coercion rules:
- `"true"` / `"false"` → boolean
- Values starting with `[` or `{` → parsed as JSON (arrays, objects)
- Everything else → plain string

Example:

```yaml
annotations:
  rootly.com/service-slug: my-service
  rootly.com/service-auto-import: enabled
  rootly.com/service-attr-color: "#FF5733"
  rootly.com/service-attr-notify_emails: '["oncall@company.com","team@company.com"]'
  rootly.com/service-attr-slack_channels: '[{"id":"C01ABC123","name":"oncall-channel"}]'
  rootly.com/service-attr-show_uptime: "true"
  rootly.com/service-attr-github_repository_name: "myorg/my-service"
```

Hardcoded fields (`name`, `description`, `backstage_id`, `pagerduty_id`, `owner_group_ids`) always take precedence and cannot be overridden via pass-through annotations.

#### Custom catalog property annotations

You can populate custom catalog properties (metadata fields) on services and catalog entities:

```yaml
rootly.com/service-property-<slug_or_id>: "value"
rootly.com/catalog-entity-property-<slug_or_id>: "value"
```

The key after the prefix is the catalog property slug or UUID. The value is passed as-is to the Rootly API.

Example:

```yaml
annotations:
  rootly.com/service-slug: my-service
  rootly.com/service-property-impact-level: "critical"
  rootly.com/service-property-slack-channel: '{"id":"C01FE4P7458","name":"service-channel"}'
```

#### Example

```yaml
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: elasticsearch-staging
  description: |
    elasticsearch-staging
  annotations:
    github.com/project-slug: backstage/backstage
    backstage.io/techdocs-ref: dir:.
    lighthouse.com/website-url: https://rootly.com
    rootly.com/service-slug: elasticsearch-staging
    pagerduty.com/service-id: <sample-service-service-id>
spec:
  type: grpc
  owner: guests
  lifecycle: experimental
```

#### Catalog Entity Example

```yaml
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: enterprise-tier
  description: Enterprise customer tier
  annotations:
    rootly.com/catalog-entity-slug: enterprise-tier
    rootly.com/catalog-entity-auto-import: enabled
    rootly.com/catalog-slug: customer-tier
    rootly.com/catalog-description: Customer pricing tiers
spec:
  type: service
  owner: guests
  lifecycle: production
```

### Global

#### `RootlyPage` component

![Rootly page](./docs/rootly-global-page.png)

Expose the Rootly global page:

```jsx
// packages/app/src/App.tsx
import { RootlyPage } from '@rootly/backstage-plugin';

// ...
const AppRoutes = () => (
  <FlatRoutes>
    // ...
    <Route path="/rootly" element={<RootlyPage />} />
    //{' '}
    <Route
      path="/rootly-sandbox"
      element={<RootlyPage organizationId="rootly-sandbox" />}
    />
    // ...
  </FlatRoutes>
);
```

Add a link to the sidebar:

```jsx
// packages/app/src/components/Root/Root.tsx
import ExtensionIcon from '@material-ui/icons/ExtensionIcon';

export const Root = ({ children }: PropsWithChildren<{}>) => (
  <SidebarPage>
    <Sidebar>
      // ...
      <SidebarItem icon={ExtensionIcon} to="rootly" text="Rootly" />
      // <SidebarItem icon={ExtensionIcon} to="rootly-sandbox" text="Rootly Sandbox" />
      // ...
    </Sidebar>
  </SidebarPage>
);
```

#### Incidents table: filters and sorting

The incidents tables on the `RootlyPage` and `RootlyIncidentsPage` include a
filter bar with **Status**, **Severity**, **Teams**, **Services** and
**Environments** filters, plus a **Show test incidents** toggle. Search,
filters, sorting and pagination are all sent to the Rootly API, so they apply
across every incident rather than only the rows of the current page.

- Filters already fixed by a page are hidden. On an entity page (scoped to a
  service, functionality, team or system) the team, service and environment
  filters are hidden because the Rootly API ORs relationship filters together,
  so adding one would widen the results instead of narrowing them. For the same
  reason, selecting several of teams, services and environments on the global
  page returns incidents linked to _any_ of the selected items.
- The **Started At**, **Mitigated At** and **Resolved At** columns can be
  sorted (newest started first by default). Other columns are not sortable
  because the Rootly API cannot sort on them.
- `IncidentsTable` is exported and accepts `params` (a fixed scope merged into
  every request) and `showFilters` (set to `false` to hide the filter bar).

### Entity

#### `RootlyOverviewCard` component

![Rootly overview page](./docs/rootly-entity-overview.png)

```jsx
// packages/app/src/components/catalog/EntityPage.tsx
import {
  RootlyOverviewCard,
  isRootlyAvailable,
} from '@rootly/backstage-plugin';

// For a service
const overviewContent = (
  <Grid container spacing={3} alignItems="stretch">
    // ...
    <EntitySwitch>
      <EntitySwitch.Case if={isRootlyAvailable}>
        <Grid item sm={6}>
          <RootlyOverviewCard />
        </Grid>
      </EntitySwitch.Case>
    </EntitySwitch>
    // ...
  </Grid>
);
```

#### `RootlyIncidentsPage` component

![Rootly incidents page](./docs/rootly-incidents-page.png)

```jsx
// packages/app/src/components/catalog/EntityPage.tsx
import { RootlyIncidentsPage } from '@rootly/backstage-plugin';

// ...
const websiteEntityPage = (
  <EntityLayout>
    <EntityLayout.Route path="/" title="Overview">
      {overviewContent}
    </EntityLayout.Route>

    // ...

    <EntityLayout.Route path="/docs" title="Docs">
      <EntityTechdocsContent />
    </EntityLayout.Route>

    <EntityLayout.Route path="/rootly" title="Rootly">
      <EntitySwitch.Case if={isRootlyAvailable}>
        <Grid item sm={6}>
          <RootlyIncidentsPage />
        </Grid>
        // Rootly Multi Organization
        // <Grid item sm={6}>
        //   <RootlyIncidentsPage organizationId="rootly-sandbox" />
        // </Grid>
      </EntitySwitch.Case>
    </EntityLayout.Route>
  </EntityLayout>
);

// ...
const serviceEntityPage = (
  <EntityLayout>
    <EntityLayout.Route path="/" title="Overview">
      {overviewContent}
    </EntityLayout.Route>

    // ...

    <EntityLayout.Route path="/docs" title="Docs">
      <EntityTechdocsContent />
    </EntityLayout.Route>

    <EntityLayout.Route path="/rootly" title="Rootly">
      <RootlyIncidentsPage />
      // Rootly Multi Organization
      // <Grid item sm={6}>
      //   <RootlyIncidentsPage organizationId="rootly-sandbox" />
    </EntityLayout.Route>
  </EntityLayout>
);

//...
const systemPage = (
  <EntityLayout>
    <EntityLayout.Route path="/" title="Overview">
      <>
        {overviewContent}
        <Grid container spacing={3} alignItems="stretch">
          {entityWarningContent}
          <Grid item md={6}>
            <EntityAboutCard variant="gridItem" />
          </Grid>
          <Grid item md={6} xs={12}>
            <EntityCatalogGraphCard variant="gridItem" height={400} />
          </Grid>
          <Grid item md={6}>
            <EntityHasComponentsCard variant="gridItem" />
          </Grid>
          <Grid item md={6}>
            <EntityHasApisCard variant="gridItem" />
          </Grid>
          <Grid item md={6}>
            <EntityHasResourcesCard variant="gridItem" />
          </Grid>
        </Grid>
      </>
    </EntityLayout.Route>
    
    // ...

    <EntityLayout.Route path="/rootly" title="Rootly">
      // Make sure to add rootly.com/organization-id annotation to all the components part of this system
      <RootlyIncidentsPage />
    </EntityLayout.Route>
  </EntityLayout>
);
```

## Entity Processor

The `@rootly/backstage-plugin-entity-processor` is a backend plugin that automatically synchronizes your Backstage catalog entities with Rootly. It's a required companion to the frontend plugin.

### Why Use the Entity Processor?

In Backstage's architecture, [entity processors](https://backstage.io/docs/features/software-catalog/external-integrations/) are middleware components that sit in the catalog's processing pipeline. They intercept entities as they flow through ingestion and can transform, validate, or enrich them.

The Rootly Entity Processor serves several purposes:

1. **Bidirectional Sync** - Automatically keeps Backstage entities and Rootly resources (services, functionalities, teams) in sync. When you annotate a Backstage entity with a Rootly service, the processor updates Rootly with the entity's `backstage_id`, creating a two-way link.

2. **Auto-Import** - When enabled via annotations (e.g., `rootly.com/service-auto-import: enabled`), the processor automatically creates corresponding resources in Rootly if they don't exist. This eliminates manual setup when onboarding new services.

3. **Annotation Management** - The processor enriches entities by adding resolved IDs back to annotations. For example, if you specify a `service-slug`, it will add the corresponding `service-id` after resolution.

4. **Multi-Organization Support** - Handles routing to different Rootly organizations based on the `rootly.com/organization-id` annotation.

### How It Works

```mermaid
flowchart LR
    subgraph Backstage Catalog
        A[Entity Provider] --> B[Rootly Entity Processor]
        B --> C[Processed Entity]
    end

    B <-->|Sync| D[Rootly API]

    subgraph Rootly
        D --> E[Services]
        D --> F[Teams]
        D --> G[Functionalities]
        D --> H[Catalog Entities]
    end
```

The processor runs during Backstage's catalog refresh cycle (typically every few minutes). For each entity with Rootly annotations:

1. **Detection** - Checks if the entity has any Rootly annotations (`service-id`, `service-slug`, `functionality-id`, etc.)
2. **Resolution** - Looks up the referenced resource in Rootly via the API
3. **Sync** - Updates the Rootly resource with the Backstage entity reference (`backstage_id`)
4. **Auto-Import** - If the resource doesn't exist and auto-import is enabled, creates it in Rootly
5. **Annotation Update** - Adds resolved IDs back to the entity's annotations

### Installation

Add the plugin to your backend app:

```bash
yarn add --cwd packages/backend @rootly/backstage-plugin-entity-processor
```

Enable the entity processor in your Backstage backend:

```ts
// packages/backend/src/index.ts
import { createBackend } from '@backstage/backend-defaults';

const backend = createBackend();

// ... other plugins

backend.add(import('@rootly/backstage-plugin-entity-processor'));

backend.start();
```

### Configuration

The entity processor uses the same configuration as the frontend plugin. Ensure your `app-config.yaml` includes the Rootly proxy configuration:

```yaml
# app-config.yaml
rootly:
  rootly-main:
    proxyPath: /rootly/api
    apiHost: https://rootly.com # Optional. Defaults to https://rootly.com

proxy:
  endpoints:
    '/rootly/api':
      target: 'https://api.rootly.com'
      headers:
        Authorization: Bearer ${ROOTLY_TOKEN}
```

### Supported Annotations

The processor responds to the following annotations:

| Annotation | Description | Auto-Import |
|------------|-------------|-------------|
| `rootly.com/service-id` | Link to a Rootly service by UUID | - |
| `rootly.com/service-slug` | Link to a Rootly service by slug | - |
| `rootly.com/service-auto-import` | Set to `enabled` to auto-create service | Yes |
| `rootly.com/functionality-id` | Link to a Rootly functionality by UUID | - |
| `rootly.com/functionality-slug` | Link to a Rootly functionality by slug | - |
| `rootly.com/functionality-auto-import` | Set to `enabled` to auto-create functionality | Yes |
| `rootly.com/team-id` | Link to a Rootly team by UUID | - |
| `rootly.com/team-slug` | Link to a Rootly team by slug | - |
| `rootly.com/team-auto-import` | Set to `enabled` to auto-create team | Yes |
| `rootly.com/organization-id` | Target Rootly organization (for multi-org setups) | - |
| `rootly.com/catalog-entity-id` | Link to a Rootly catalog entity by UUID | - |
| `rootly.com/catalog-entity-slug` | Link to a Rootly catalog entity by slug | - |
| `rootly.com/catalog-entity-auto-import` | Set to `enabled` to auto-create catalog entity | Yes |
| `rootly.com/catalog-id` | Target catalog UUID (required for auto-import) | - |
| `rootly.com/catalog-slug` | Target catalog slug (alternative to catalog-id) | - |
| `rootly.com/catalog-description` | Description when auto-creating a catalog | - |

### Example: Auto-Import Service

```yaml
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: payments-service
  annotations:
    rootly.com/service-slug: payments-service
    rootly.com/service-auto-import: enabled  # Creates service in Rootly if not found
spec:
  type: service
  owner: payments-team
  lifecycle: production
```

When this entity is processed:
- If `payments-service` exists in Rootly → links it to this Backstage entity
- If `payments-service` doesn't exist → creates it in Rootly and links it

## New Frontend System

Follow these steps to detect and configure the Rootly plugin if you'd like to use it in an application that supports the new Backstage frontend system.

### Package Detection

Once you install the `@rootly/backstage-plugin` package using your preferred package manager, you have to choose how the package should be detected by the app. The package can be automatically discovered when the feature discovery config is set, or it can be manually enabled via code (for more granular package customization cases).

<table>
  <tr>
    <td>Via config</td>
    <td>Via code</td>
  </tr>
  <tr>
    <td>
      <pre lang="yaml">
        <code>
# app-config.yaml
  app:
    # Enable package discovery for all plugins
    packages: 'all'
  ---
  app:
    # Enable package discovery only for Rootly
    packages:
      include:
        - '@rootly/backstage-plugin'
        </code>
      </pre>
    </td>
    <td>
      <pre lang="javascript">
       <code>
// packages/app/src/App.tsx
import { createApp } from '@backstage/frontend-defaults';
import rootlyPlugin from '@rootly/backstage-plugin/alpha';
//...
const app = createApp({
  // ...
  features: [
    //...
    rootlyPlugin,
  ],
});

//...
       </code>
      </pre>
    </td>
  </tr>
</table>

### Extensions Configuration

Currently, the plugin installs 5 extensions: 1 api, 1 page, 1 nav item (sidebar item), 1 entity page card and 1 entity page content (also known as entity page tab), see below examples of how to configure the available extensions. 

```yml
# app-config.yaml
app:
  extensions:
    # Example customizing the Rootly path
    - 'page:rootly':
        config:
          path: '/incidents'
    # Example removing the Rootly sidebar item
    - 'nav-item:rootly': false
    # Example changing the Rootly sidebar title
    - 'nav-item:rootly':
        config:
          title: 'Incidents'
    # Example disabling the Rootly entity card
    - 'entity-card:rootly': false
    # Example disabling the Rootly entity content
    - 'entity-content:rootly': false
    # Example customizing the Rootly entity content
    - 'entity-content:rootly':
        config:
          path: '/incidents'
          title: 'incidents'
```

## License

This library is under the [MIT](LICENSE) license.

---
_Source: https://npm.io/package/@rootly/backstage-plugin · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._
