EntitySearchQuery

Search for entities.

Usage

import { EntitySearchQuery } from 'nr1';

Examples

Declarative query

function render() {
  const filters = [
    {
      type: EntitySearchQuery.FILTER_TYPE.TAG,
      value: { key: 'environment', value: 'production' },
    },
  ];

  return (
    <EntitySearchQuery filters={filters}>
      {({ loading, error, data, fetchMore }) => {
        if (loading) {
          return <Spinner />;
        }

        if (error) {
          return 'Error!';
        }

        return (
          <List
            items={data.entities}
            rowCount={data.count}
            rowHeight={20}
            onLoadMore={fetchMore}
          >
            {({ item }) => <ListItem key={item.guid}>{item.name}</ListItem>}
          </List>
        );
      }}
    </EntitySearchQuery>
  );
}

Fetch with sorting criteria

<EntitySearchQuery
  entityDomain="APM"
  sortType={[EntitySearchQuery.SORT_TYPE.ALERT_SEVERITY]}
>
  {({ data, error, fetchMore }) => {
    if (error) {
      return 'Error!';
    }

    return (
      <List
        items={data.entities}
        rowCount={data.count}
        rowHeight={20}
        onLoadMore={fetchMore}
      >
        {({ item }) => <ListItem key={item.guid}>{item.name}</ListItem>}
      </List>
    );
  }}
</EntitySearchQuery>;

Imperative query

EntitySearchQuery.query({
  filters: [
    {
      type: EntitySearchQuery.FILTER_TYPE.TAG,
      value: { key: 'environment', value: 'production' },
    },
  ],
}).then(({ data }) => console.log(data));

Fetch more results using imperative query

const filters = [
  {
    type: EntitySearchQuery.FILTER_TYPE.TAG,
    value: { key: 'environment', value: 'production' },
  },
];

const firstPage = await EntitySearchQuery.query({ filters });

console.log('First page data', firstPage.data);

const cursor = firstPage.data.nextCursor;
const secondPage = await EntitySearchQuery.query({ cursor, filters });

console.log('Second page data', secondPage.data);

// NOTE: To fetch multiple page results consecutively, use EntitySearchQuery
// component's fetchMore approach.

Props

children

function

Render prop function as a child.

function (queryResult: QueryResult Results of the query.
) => React.ReactNode

entityDomain

string

Domain of the entities you want to query.

entityFragmentExtension

object

GraphQL fragment document parsed into an AST by graphql-tag.The Query components return the most commonly used fields available on an entity. You can use this prop when you want to request additional fields for the entities returned by your query.The fragment should be named EntityFragmentExtension and apply to the EntityOutline type.

const entityFragmentExtension = ngql`
  fragment EntityFragmentExtension on EntityOutline {
    indexedAt
    guid
  }
`;

entityGuids

string[]

GUID of the entities to query.

entityType

string

Type of the entities you want to query.

fetchPolicyType

enum

Allows you to specify how you want your query to interact with the cached data.

CACHE_AND_NETWORK: The query returns your initial data from the cache if available. However, regardless of whether or not the full data is in your cache, the query always makes a request using your network interface and returns the updated data. This option is not available when using the static query() method of the component.
CACHE_FIRST: The query makes a request using your network interface only if the data for your query is not already in the cache.
CACHE_ONLY: The query never makes a request using your network interface. Instead it returns the data available in the cache. If the data for your query does not exist in the cache, then an error is thrown.
NETWORK_ONLY: The query never returns your initial data from the cache. Instead it always makes a request using your network interface.
NO_CACHE: The query never returns your initial data from the cache. Instead it always makes a request using your network interface. Unlike the NETWORK_ONLY policy, it does not write any data to the cache after the query completes.
<One ofEntitySearchQuery.FETCH_POLICY_TYPE.CACHE_AND_NETWORK, EntitySearchQuery.FETCH_POLICY_TYPE.CACHE_FIRST, EntitySearchQuery.FETCH_POLICY_TYPE.CACHE_ONLY, EntitySearchQuery.FETCH_POLICY_TYPE.NETWORK_ONLY, EntitySearchQuery.FETCH_POLICY_TYPE.NO_CACHE, >

filters

string|(shape|shape|shape)[]

Filters used to narrow down the entities.This is an array of filters, and there are 3 possible filters:

SearchQueryFilter: Object<type: string = "searchQuery", value: string>
EntityTypeFilter: Object<type: string = "entityType", Object<domain: string, type: string>>

TagFilter: Object<type: string = "tag", Object<key: string, value: string>>

const filters = [
  {
    type: 'searchQuery',
    value: 'foo',
  },
  {
    type: 'entityType',
    value: { domain: 'APM', type: 'APPLICATION' },
  },
  {
    type: 'tag',
    value: { key: 'environment', value: 'production' },
  },
  {
    type: 'tag',
    value: { key: 'team', value: 'bar' },
  },
];

includeCount

boolean

If true, the query response includes the total count of entities for each domain and type.

includeResults

boolean

If true, the query response includes entities.

includeSummaryMetrics

boolean

includeTags

boolean

If true, the returned entities include their tags.

limit

number

Pagination, number of entities to fetch for on each page.

name

string

Name or partial name of the entities to query.

pollInterval

number

Interval in milliseconds to poll for new data. Set to zero to avoid any kind of regular polling.

skip

boolean

When set to true, the query will be skipped entirely from rendering.

sortBy

DEPRECATED

Due November 1st, 2023

The sortBy is deprecated, use sortType instead

sortType

enum[]

Array of criteras used to sort the entity search results.

<Array of<One ofEntitySearchQuery.SORT_TYPE.ALERT_SEVERITY,
EntitySearchQuery.SORT_TYPE.DOMAIN,
EntitySearchQuery.SORT_TYPE.MOST_RELEVANT,
EntitySearchQuery.SORT_TYPE.NAME,
EntitySearchQuery.SORT_TYPE.REPORTING,
EntitySearchQuery.SORT_TYPE.TYPE,
>
>

Methods