[Infra UI] Refactor 'capabilites' to 'metadata'.

x-pack/plugins/infra/common/graphql/introspection.json

@@ -111,8 +111,8 @@
             "deprecationReason": null
           },
           {
-            "name": "capabilitiesByNode",
-            "description": "A hierarchy of capabilities available on nodes",
+            "name": "metadataByNode",
+            "description": "A hierarchy of metadata entries by node",
             "args": [
               {
                 "name": "nodeName",
@@ -141,7 +141,7 @@
               "ofType": {
                 "kind": "LIST",
                 "name": null,
-                "ofType": { "kind": "OBJECT", "name": "InfraNodeCapability", "ofType": null }
+                "ofType": { "kind": "OBJECT", "name": "InfraNodeMetadata", "ofType": null }
               }
             },
             "isDeprecated": false,
@@ -781,9 +781,8 @@
       },
       {
         "kind": "OBJECT",
-        "name": "InfraNodeCapability",
-        "description":
-          "One specific capability available on a node. A capability corresponds to a fileset or metricset",
+        "name": "InfraNodeMetadata",
+        "description": "One metadata entry for a node.",
         "fields": [
           {
             "name": "name",

x-pack/plugins/infra/common/graphql/types.ts

@@ -17,7 +17,7 @@ export interface InfraSource {
   id: string /** The id of the source */;
   configuration: InfraSourceConfiguration /** The raw configuration of the source */;
   status: InfraSourceStatus /** The status of the source */;
-  capabilitiesByNode: (InfraNodeCapability | null)[] /** A hierarchy of capabilities available on nodes */;
+  metadataByNode: (InfraNodeMetadata | null)[] /** A hierarchy of metadata entries by node */;
   logEntriesAround: InfraLogEntryInterval /** A consecutive span of log entries surrounding a point in time */;
   logEntriesBetween: InfraLogEntryInterval /** A consecutive span of log entries within an interval */;
   logSummaryBetween: InfraLogSummaryInterval /** A consecutive span of summary buckets within an interval */;
@@ -56,8 +56,8 @@ export interface InfraIndexField {
   searchable: boolean /** Whether the field's values can be efficiently searched for */;
   aggregatable: boolean /** Whether the field's values can be aggregated */;
 }
-/** One specific capability available on a node. A capability corresponds to a fileset or metricset */
-export interface InfraNodeCapability {
+/** One metadata entry for a node. */
+export interface InfraNodeMetadata {
   name: string;
   source: string;
 }
@@ -163,7 +163,7 @@ export namespace InfraSourceResolvers {
     id?: IdResolver /** The id of the source */;
     configuration?: ConfigurationResolver /** The raw configuration of the source */;
     status?: StatusResolver /** The status of the source */;
-    capabilitiesByNode?: CapabilitiesByNodeResolver /** A hierarchy of capabilities available on nodes */;
+    metadataByNode?: MetadataByNodeResolver /** A hierarchy of metadata entries by node */;
     logEntriesAround?: LogEntriesAroundResolver /** A consecutive span of log entries surrounding a point in time */;
     logEntriesBetween?: LogEntriesBetweenResolver /** A consecutive span of log entries within an interval */;
     logSummaryBetween?: LogSummaryBetweenResolver /** A consecutive span of summary buckets within an interval */;
@@ -174,11 +174,8 @@ export namespace InfraSourceResolvers {
   export type IdResolver = Resolver<string>;
   export type ConfigurationResolver = Resolver<InfraSourceConfiguration>;
   export type StatusResolver = Resolver<InfraSourceStatus>;
-  export type CapabilitiesByNodeResolver = Resolver<
-    (InfraNodeCapability | null)[],
-    CapabilitiesByNodeArgs
-  >;
-  export interface CapabilitiesByNodeArgs {
+  export type MetadataByNodeResolver = Resolver<(InfraNodeMetadata | null)[], MetadataByNodeArgs>;
+  export interface MetadataByNodeArgs {
     nodeName: string;
     nodeType: InfraNodeType;
   }
@@ -289,8 +286,8 @@ export namespace InfraIndexFieldResolvers {
   export type SearchableResolver = Resolver<boolean>;
   export type AggregatableResolver = Resolver<boolean>;
 }
-/** One specific capability available on a node. A capability corresponds to a fileset or metricset */
-export namespace InfraNodeCapabilityResolvers {
+/** One metadata entry for a node. */
+export namespace InfraNodeMetadataResolvers {
   export interface Resolvers {
     name?: NameResolver;
     source?: SourceResolver;
@@ -493,7 +490,7 @@ export interface InfraMetricInput {
 export interface SourceQueryArgs {
   id: string /** The id of the source */;
 }
-export interface CapabilitiesByNodeInfraSourceArgs {
+export interface MetadataByNodeInfraSourceArgs {
   nodeName: string;
   nodeType: InfraNodeType;
 }
@@ -604,7 +601,7 @@ export enum InfraOperator {
 /** A segment of the log entry message */
 export type InfraLogMessageSegment = InfraLogMessageFieldSegment | InfraLogMessageConstantSegment;
 
-export namespace CapabilitiesQuery {
+export namespace MetadataQuery {
   export type Variables = {
     sourceId: string;
     nodeId: string;
@@ -619,11 +616,11 @@ export namespace CapabilitiesQuery {
   export type Source = {
     __typename?: 'InfraSource';
     id: string;
-    capabilitiesByNode: (CapabilitiesByNode | null)[];
+    metadataByNode: (MetadataByNode | null)[];
   };
 
-  export type CapabilitiesByNode = {
-    __typename?: 'InfraNodeCapability';
+  export type MetadataByNode = {
+    __typename?: 'InfraNodeMetadata';
     name: string;
     source: string;
   };
@@ -815,6 +812,7 @@ export namespace SourceQuery {
 
   export type Source = {
     __typename?: 'InfraSource';
+    id: string;
     configuration: Configuration;
     status: Status;
   };

x-pack/plugins/infra/public/containers/capabilities/capabilities.gql_query.ts → x-pack/plugins/infra/public/containers/metadata/metadata.gql_query.ts

@@ -6,11 +6,11 @@
 
 import gql from 'graphql-tag';
 
-export const capabilitiesQuery = gql`
-  query CapabilitiesQuery($sourceId: ID!, $nodeId: String!, $nodeType: InfraNodeType!) {
+export const metadataQuery = gql`
+  query MetadataQuery($sourceId: ID!, $nodeId: String!, $nodeType: InfraNodeType!) {
     source(id: $sourceId) {
       id
-      capabilitiesByNode(nodeName: $nodeId, nodeType: $nodeType) {
+      metadataByNode(nodeName: $nodeId, nodeType: $nodeType) {
         name
         source
       }

x-pack/plugins/infra/public/containers/capabilities/with_capabilites.tsx → x-pack/plugins/infra/public/containers/metadata/with_metadata.tsx

@@ -8,34 +8,34 @@ import _ from 'lodash';
 
 import React from 'react';
 import { Query } from 'react-apollo';
-import { CapabilitiesQuery, InfraNodeType } from '../../../common/graphql/types';
+import { InfraNodeType, MetadataQuery } from '../../../common/graphql/types';
 import { InfraMetricLayout } from '../../pages/metrics/layouts/types';
-import { capabilitiesQuery } from './capabilities.gql_query';
+import { metadataQuery } from './metadata.gql_query';
 
-interface WithCapabilitiesProps {
-  children: (args: WithCapabilitiesArgs) => React.ReactNode;
+interface WithMetadataProps {
+  children: (args: WithMetadataArgs) => React.ReactNode;
   layouts: InfraMetricLayout[];
   nodeType: InfraNodeType;
   nodeId: string;
   sourceId: string;
 }
 
-interface WithCapabilitiesArgs {
+interface WithMetadataArgs {
   filteredLayouts: InfraMetricLayout[];
   error?: string | undefined;
   loading: boolean;
 }
 
-export const WithCapabilities = ({
+export const WithMetadata = ({
   children,
   layouts,
   nodeType,
   nodeId,
   sourceId,
-}: WithCapabilitiesProps) => {
+}: WithMetadataProps) => {
   return (
-    <Query<CapabilitiesQuery.Query, CapabilitiesQuery.Variables>
-      query={capabilitiesQuery}
+    <Query<MetadataQuery.Query, MetadataQuery.Variables>
+      query={metadataQuery}
       fetchPolicy="no-cache"
       variables={{
         sourceId,
@@ -44,8 +44,8 @@ export const WithCapabilities = ({
       }}
     >
       {({ data, error, loading }) => {
-        const capabilities = data && data.source && data.source.capabilitiesByNode;
-        const filteredLayouts = getFilteredLayouts(layouts, capabilities);
+        const metadata = data && data.source && data.source.metadataByNode;
+        const filteredLayouts = getFilteredLayouts(layouts, metadata);
         return children({
           filteredLayouts,
           error: error && error.message,
@@ -58,31 +58,31 @@ export const WithCapabilities = ({
 
 const getFilteredLayouts = (
   layouts: InfraMetricLayout[],
-  capabilities: Array<CapabilitiesQuery.CapabilitiesByNode | null> | undefined
+  metadata: Array<MetadataQuery.MetadataByNode | null> | undefined
 ): InfraMetricLayout[] => {
-  if (!capabilities) {
+  if (!metadata) {
     return layouts;
   }
 
-  const metricCapabilities: Array<string | null> = capabilities
-    .filter(cap => cap && cap.source === 'metrics')
-    .map(cap => cap && cap.name);
+  const metricMetadata: Array<string | null> = metadata
+    .filter(data => data && data.source === 'metrics')
+    .map(data => data && data.name);
 
   // After filtering out sections that can't be displayed, a layout may end up empty and can be removed.
   const filteredLayouts = layouts
-    .map(layout => getFilteredLayout(layout, metricCapabilities))
+    .map(layout => getFilteredLayout(layout, metricMetadata))
     .filter(layout => layout.sections.length > 0);
   return filteredLayouts;
 };
 
 const getFilteredLayout = (
   layout: InfraMetricLayout,
-  metricCapabilities: Array<string | null>
+  metricMetadata: Array<string | null>
 ): InfraMetricLayout => {
   // A section is only displayed if at least one of its requirements is met
   // All others are filtered out.
   const filteredSections = layout.sections.filter(
-    section => _.intersection(section.requires, metricCapabilities).length > 0
+    section => _.intersection(section.requires, metricMetadata).length > 0
   );
   return { ...layout, sections: filteredSections };
 };

x-pack/plugins/infra/public/pages/metrics/index.tsx

@@ -25,7 +25,7 @@ import { Header } from '../../components/header';
 import { Metrics } from '../../components/metrics';
 import { MetricsTimeControls } from '../../components/metrics/time_controls';
 import { ColumnarPage, PageContent } from '../../components/page';
-import { WithCapabilities } from '../../containers/capabilities/with_capabilites';
+import { WithMetadata } from '../../containers/metadata/with_metadata';
 import { WithMetrics } from '../../containers/metrics/with_metrics';
 import {
   WithMetricsTime,
@@ -88,7 +88,7 @@ class MetricDetailPage extends React.PureComponent<Props> {
                   startMetricsAutoReload,
                   stopMetricsAutoReload,
                 }) => (
-                  <WithCapabilities
+                  <WithMetadata
                     layouts={layouts}
                     sourceId={sourceId}
                     nodeType={nodeType}
@@ -183,7 +183,7 @@ class MetricDetailPage extends React.PureComponent<Props> {
                         </WithMetrics>
                       );
                     }}
-                  </WithCapabilities>
+                  </WithMetadata>
                 )}
               </WithMetricsTime>
             )}

x-pack/plugins/infra/server/graphql/index.ts

@@ -6,8 +6,8 @@
 
 import { rootSchema } from '../../common/graphql/root/schema.gql';
 import { sharedSchema } from '../../common/graphql/shared/schema.gql';
-import { capabilitiesSchema } from './capabilities/schema.gql';
 import { logEntriesSchema } from './log_entries/schema.gql';
+import { metadataSchema } from './metadata/schema.gql';
 import { metricsSchema } from './metrics/schema.gql';
 import { nodesSchema } from './nodes/schema.gql';
 import { sourceStatusSchema } from './source_status/schema.gql';
@@ -16,7 +16,7 @@ import { sourcesSchema } from './sources/schema.gql';
 export const schemas = [
   rootSchema,
   sharedSchema,
-  capabilitiesSchema,
+  metadataSchema,
   logEntriesSchema,
   nodesSchema,
   sourcesSchema,

x-pack/plugins/infra/server/graphql/capabilities/index.ts → x-pack/plugins/infra/server/graphql/metadata/index.ts

@@ -4,5 +4,5 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-export { createCapabilitiesResolvers } from './resolvers';
-export { capabilitiesSchema } from './schema.gql';
+export { createMetadataResolvers } from './resolvers';
+export { metadataSchema } from './schema.gql';

x-pack/plugins/infra/server/graphql/capabilities/resolvers.ts → x-pack/plugins/infra/server/graphql/metadata/resolvers.ts

@@ -6,31 +6,26 @@
 
 import { InfraSourceResolvers } from '../../../common/graphql/types';
 import { InfraResolvedResult, InfraResolverOf } from '../../lib/adapters/framework';
-import { InfraCapabilitiesDomain } from '../../lib/domains/capabilities_domain';
+import { InfraMetadataDomain } from '../../lib/domains/metadata_domain';
 import { InfraContext } from '../../lib/infra_types';
 import { QuerySourceResolver } from '../sources/resolvers';
 
-type InfraSourceCapabilitiesByNodeResolver = InfraResolverOf<
-  InfraSourceResolvers.CapabilitiesByNodeResolver,
+type InfraSourceMetadataByNodeResolver = InfraResolverOf<
+  InfraSourceResolvers.MetadataByNodeResolver,
   InfraResolvedResult<QuerySourceResolver>,
   InfraContext
 >;
 
-export const createCapabilitiesResolvers = (libs: {
-  capabilities: InfraCapabilitiesDomain;
+export const createMetadataResolvers = (libs: {
+  metadata: InfraMetadataDomain;
 }): {
   InfraSource: {
-    capabilitiesByNode: InfraSourceCapabilitiesByNodeResolver;
+    metadataByNode: InfraSourceMetadataByNodeResolver;
   };
 } => ({
   InfraSource: {
-    async capabilitiesByNode(source, args, { req }) {
-      const result = await libs.capabilities.getCapabilities(
-        req,
-        source.id,
-        args.nodeName,
-        args.nodeType
-      );
+    async metadataByNode(source, args, { req }) {
+      const result = await libs.metadata.getMetadata(req, source.id, args.nodeName, args.nodeType);
       return result;
     },
   },

x-pack/plugins/infra/server/graphql/capabilities/schema.gql.ts → x-pack/plugins/infra/server/graphql/metadata/schema.gql.ts

@@ -6,15 +6,15 @@
 
 import gql from 'graphql-tag';
 
-export const capabilitiesSchema = gql`
-  "One specific capability available on a node. A capability corresponds to a fileset or metricset"
-  type InfraNodeCapability {
+export const metadataSchema = gql`
+  "One metadata entry for a node."
+  type InfraNodeMetadata {
     name: String!
     source: String!
   }
 
   extend type InfraSource {
-    "A hierarchy of capabilities available on nodes"
-    capabilitiesByNode(nodeName: String!, nodeType: InfraNodeType!): [InfraNodeCapability]!
+    "A hierarchy of metadata entries by node"
+    metadataByNode(nodeName: String!, nodeType: InfraNodeType!): [InfraNodeMetadata]!
   }
 `;

x-pack/plugins/infra/server/infra_server.ts

@@ -6,8 +6,8 @@
 
 import { IResolvers, makeExecutableSchema } from 'graphql-tools';
 import { schemas } from './graphql';
-import { createCapabilitiesResolvers } from './graphql/capabilities';
 import { createLogEntriesResolvers } from './graphql/log_entries';
+import { createMetadataResolvers } from './graphql/metadata';
 import { createMetricResolvers } from './graphql/metrics/resolvers';
 import { createNodeResolvers } from './graphql/nodes';
 import { createSourceStatusResolvers } from './graphql/source_status';
@@ -18,7 +18,7 @@ import { initLegacyLoggingRoutes } from './logging_legacy';
 export const initInfraServer = (libs: InfraBackendLibs) => {
   const schema = makeExecutableSchema({
     resolvers: [
-      createCapabilitiesResolvers(libs) as IResolvers,
+      createMetadataResolvers(libs) as IResolvers,
       createLogEntriesResolvers(libs) as IResolvers,
       createNodeResolvers(libs) as IResolvers,
       createSourcesResolvers(libs) as IResolvers,

x-pack/plugins/infra/server/lib/adapters/framework/adapter_types.ts

@@ -148,15 +148,15 @@ export interface InfraDateRangeAggregationResponse {
   buckets: InfraDateRangeAggregationBucket[];
 }
 
-export interface InfraCapabilityAggregationBucket {
+export interface InfraMetadataAggregationBucket {
   key: string;
   names?: {
-    buckets: InfraCapabilityAggregationBucket[];
+    buckets: InfraMetadataAggregationBucket[];
   };
 }
 
-export interface InfraCapabilityAggregationResponse {
-  buckets: InfraCapabilityAggregationBucket[];
+export interface InfraMetadataAggregationResponse {
+  buckets: InfraMetadataAggregationBucket[];
 }
 
 export interface InfraFieldsResponse {