github-mirrors/kibana
1
0
Fork 0
mirror of https://github.com/elastic/kibana.git synced 2025-04-23 17:28:26 -04:00
Code Issues Projects Releases Packages Wiki Activity

[Infra UI] Fix graphql type generation after package upgrades (#26991) (#27340)

Browse source 
This fixes the infrastructure UI graphql type generation after relevant packages have been upgraded in #25157.
This commit is contained in:
Chris Cowan 2018-12-17 14:12:45 -07:00 • committed by GitHub
parent 08c73e6a49
commit 66eaefeb9d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
88 changed files with 2163 additions and 1230 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.i18nrc.json
View file

@ -35,7 +35,9 @@
"exclude": [
"src/ui/ui_render/bootstrap/app_bootstrap.js",
"src/ui/ui_render/ui_render_mixin.js",
"x-pack/plugins/infra/public/graphql/types.ts",
"x-pack/plugins/infra/public/utils/loading_state/loading_result.ts",
"x-pack/plugins/infra/server/graphql/types.ts",
"x-pack/plugins/infra/server/lib/domains/log_entries_domain/log_entries_domain.ts"
]

1
x-pack/package.json
View file

@ -79,6 +79,7 @@
"fetch-mock": "^5.13.1",
"graphql-code-generator": "^0.13.0",
"graphql-codegen-introspection-template": "^0.13.0",
"graphql-codegen-typescript-resolvers-template": "^0.13.0",
"graphql-codegen-typescript-template": "^0.13.0",
"gulp": "3.9.1",
"gulp-mocha": "2.2.0",

82
x-pack/plugins/infra/common/graphql/typed_resolvers.ts
View file

@ -1,82 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
import { GraphQLResolveInfo } from 'graphql';
type BasicResolver<Result, Args = any> = (
parent: any,
args: Args,
context: any,
info: GraphQLResolveInfo
) => Promise<Result> | Result;
type InfraResolverResult<R> =
| Promise<R>
| Promise<{ [P in keyof R]: () => Promise<R[P]> }>
| { [P in keyof R]: () => Promise<R[P]> }
| { [P in keyof R]: () => R[P] }
| R;
export type InfraResolvedResult<Resolver> = Resolver extends InfraResolver<
infer Result,
any,
any,
any
>
? Result
: never;
export type SubsetResolverWithFields<R, IncludedFields extends string> = R extends BasicResolver<
Array<infer ResultInArray>,
infer ArgsInArray
>
? BasicResolver<
Array<Pick<ResultInArray, Extract<keyof ResultInArray, IncludedFields>>>,
ArgsInArray
>
: R extends BasicResolver<infer Result, infer Args>
? BasicResolver<Pick<Result, Extract<keyof Result, IncludedFields>>, Args>
: never;
export type SubsetResolverWithoutFields<R, ExcludedFields extends string> = R extends BasicResolver<
Array<infer ResultInArray>,
infer ArgsInArray
>
? BasicResolver<
Array<Pick<ResultInArray, Exclude<keyof ResultInArray, ExcludedFields>>>,
ArgsInArray
>
: R extends BasicResolver<infer Result, infer Args>
? BasicResolver<Pick<Result, Exclude<keyof Result, ExcludedFields>>, Args>
: never;
export type InfraResolver<Result, Parent, Args, Context> = (
parent: Parent,
args: Args,
context: Context,
info: GraphQLResolveInfo
) => InfraResolverResult<Result>;
export type InfraResolverOf<Resolver, Parent, Context> = Resolver extends BasicResolver<
infer Result,
infer Args
>
? InfraResolver<Result, Parent, Args, Context>
: never;
export type InfraResolverWithFields<
Resolver,
Parent,
Context,
IncludedFields extends string
> = InfraResolverOf<SubsetResolverWithFields<Resolver, IncludedFields>, Parent, Context>;
export type InfraResolverWithoutFields<
Resolver,
Parent,
Context,
ExcludedFields extends string
> = InfraResolverOf<SubsetResolverWithoutFields<Resolver, ExcludedFields>, Parent, Context>;

856
x-pack/plugins/infra/common/graphql/types.ts
View file

@ -1,856 +0,0 @@
/* tslint:disable */
import { GraphQLResolveInfo } from 'graphql';
type Resolver<Result, Args = any> = (
parent: any,
args: Args,
context: any,
info: GraphQLResolveInfo
) => Promise<Result> | Result;
export interface Query {
source: InfraSource /** Get an infrastructure data source by id */;
allSources: InfraSource[] /** Get a list of all infrastructure data sources */;
}
/** A source of infrastructure data */
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 */;
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 */;
map?: InfraResponse | null /** A hierarchy of hosts, pods, containers, services or arbitrary groups */;
metrics: InfraMetricData[];
}
/** A set of configuration options for an infrastructure data source */
export interface InfraSourceConfiguration {
metricAlias: string /** The alias to read metric data from */;
logAlias: string /** The alias to read log data from */;
fields: InfraSourceFields /** The field mapping to use for this source */;
}
/** A mapping of semantic fields to their document counterparts */
export interface InfraSourceFields {
container: string /** The field to identify a container by */;
host: string /** The fields to identify a host by */;
message: string[] /** The fields that may contain the log event message. The first field found win. */;
pod: string /** The field to identify a pod by */;
tiebreaker: string /** The field to use as a tiebreaker for log events that have identical timestamps */;
timestamp: string /** The field to use as a timestamp for metrics and logs */;
}
/** The status of an infrastructure data source */
export interface InfraSourceStatus {
metricAliasExists: boolean /** Whether the configured metric alias exists */;
logAliasExists: boolean /** Whether the configured log alias exists */;
metricIndicesExist: boolean /** Whether the configured alias or wildcard pattern resolve to any metric indices */;
logIndicesExist: boolean /** Whether the configured alias or wildcard pattern resolve to any log indices */;
metricIndices: string[] /** The list of indices in the metric alias */;
logIndices: string[] /** The list of indices in the log alias */;
indexFields: InfraIndexField[] /** The list of fields defined in the index mappings */;
}
/** A descriptor of a field in an index */
export interface InfraIndexField {
name: string /** The name of the field */;
type: string /** The type of the field's values as recognized by Kibana */;
searchable: boolean /** Whether the field's values can be efficiently searched for */;
aggregatable: boolean /** Whether the field's values can be aggregated */;
}
/** One metadata entry for a node. */
export interface InfraNodeMetadata {
name: string;
source: string;
}
/** A consecutive sequence of log entries */
export interface InfraLogEntryInterval {
start?: InfraTimeKey | null /** The key corresponding to the start of the interval covered by the entries */;
end?: InfraTimeKey | null /** The key corresponding to the end of the interval covered by the entries */;
hasMoreBefore: boolean /** Whether there are more log entries available before the start */;
hasMoreAfter: boolean /** Whether there are more log entries available after the end */;
filterQuery?: string | null /** The query the log entries were filtered by */;
highlightQuery?: string | null /** The query the log entries were highlighted with */;
entries: InfraLogEntry[] /** A list of the log entries */;
}
/** A representation of the log entry's position in the event stream */
export interface InfraTimeKey {
time: number /** The timestamp of the event that the log entry corresponds to */;
tiebreaker: number /** The tiebreaker that disambiguates events with the same timestamp */;
}
/** A log entry */
export interface InfraLogEntry {
key: InfraTimeKey /** A unique representation of the log entry's position in the event stream */;
gid: string /** The log entry's id */;
source: string /** The source id */;
message: InfraLogMessageSegment[] /** A list of the formatted log entry segments */;
}
/** A segment of the log entry message that was derived from a field */
export interface InfraLogMessageFieldSegment {
field: string /** The field the segment was derived from */;
value: string /** The segment's message */;
highlights: string[] /** A list of highlighted substrings of the value */;
}
/** A segment of the log entry message that was derived from a field */
export interface InfraLogMessageConstantSegment {
constant: string /** The segment's message */;
}
/** A consecutive sequence of log summary buckets */
export interface InfraLogSummaryInterval {
start?:
| number
| null /** The millisecond timestamp corresponding to the start of the interval covered by the summary */;
end?:
| number
| null /** The millisecond timestamp corresponding to the end of the interval covered by the summary */;
filterQuery?: string | null /** The query the log entries were filtered by */;
buckets: InfraLogSummaryBucket[] /** A list of the log entries */;
}
/** A log summary bucket */
export interface InfraLogSummaryBucket {
start: number /** The start timestamp of the bucket */;
end: number /** The end timestamp of the bucket */;
entriesCount: number /** The number of entries inside the bucket */;
}
export interface InfraResponse {
nodes: InfraNode[];
}
export interface InfraNode {
path: InfraNodePath[];
metric: InfraNodeMetric;
}
export interface InfraNodePath {
value: string;
}
export interface InfraNodeMetric {
name: InfraMetricType;
value: number;
}
export interface InfraMetricData {
id?: InfraMetric | null;
series: InfraDataSeries[];
}
export interface InfraDataSeries {
id: string;
data: InfraDataPoint[];
}
export interface InfraDataPoint {
timestamp: number;
value?: number | null;
}
export namespace QueryResolvers {
export interface Resolvers {
source?: SourceResolver /** Get an infrastructure data source by id */;
allSources?: AllSourcesResolver /** Get a list of all infrastructure data sources */;
}
export type SourceResolver = Resolver<InfraSource, SourceArgs>;
export interface SourceArgs {
id: string /** The id of the source */;
}
export type AllSourcesResolver = Resolver<InfraSource[]>;
}
/** A source of infrastructure data */
export namespace InfraSourceResolvers {
export interface Resolvers {
id?: IdResolver /** The id of the source */;
configuration?: ConfigurationResolver /** The raw configuration of the source */;
status?: StatusResolver /** The status of the source */;
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 */;
map?: MapResolver /** A hierarchy of hosts, pods, containers, services or arbitrary groups */;
metrics?: MetricsResolver;
}
export type IdResolver = Resolver<string>;
export type ConfigurationResolver = Resolver<InfraSourceConfiguration>;
export type StatusResolver = Resolver<InfraSourceStatus>;
export type MetadataByNodeResolver = Resolver<(InfraNodeMetadata | null)[], MetadataByNodeArgs>;
export interface MetadataByNodeArgs {
nodeName: string;
nodeType: InfraNodeType;
}
export type LogEntriesAroundResolver = Resolver<InfraLogEntryInterval, LogEntriesAroundArgs>;
export interface LogEntriesAroundArgs {
key: InfraTimeKeyInput /** The sort key that corresponds to the point in time */;
countBefore?: number | null /** The maximum number of preceding to return */;
countAfter?: number | null /** The maximum number of following to return */;
filterQuery?: string | null /** The query to filter the log entries by */;
highlightQuery?: string | null /** The query to highlight the log entries with */;
}
export type LogEntriesBetweenResolver = Resolver<InfraLogEntryInterval, LogEntriesBetweenArgs>;
export interface LogEntriesBetweenArgs {
startKey: InfraTimeKeyInput /** The sort key that corresponds to the start of the interval */;
endKey: InfraTimeKeyInput /** The sort key that corresponds to the end of the interval */;
filterQuery?: string | null /** The query to filter the log entries by */;
highlightQuery?: string | null /** The query to highlight the log entries with */;
}
export type LogSummaryBetweenResolver = Resolver<InfraLogSummaryInterval, LogSummaryBetweenArgs>;
export interface LogSummaryBetweenArgs {
start: number /** The millisecond timestamp that corresponds to the start of the interval */;
end: number /** The millisecond timestamp that corresponds to the end of the interval */;
bucketSize: number /** The size of each bucket in milliseconds */;
filterQuery?: string | null /** The query to filter the log entries by */;
}
export type MapResolver = Resolver<InfraResponse | null, MapArgs>;
export interface MapArgs {
timerange: InfraTimerangeInput;
filterQuery?: string | null;
}
export type MetricsResolver = Resolver<InfraMetricData[], MetricsArgs>;
export interface MetricsArgs {
nodeId: string;
nodeType: InfraNodeType;
timerange: InfraTimerangeInput;
metrics: InfraMetric[];
}
}
/** A set of configuration options for an infrastructure data source */
export namespace InfraSourceConfigurationResolvers {
export interface Resolvers {
metricAlias?: MetricAliasResolver /** The alias to read metric data from */;
logAlias?: LogAliasResolver /** The alias to read log data from */;
fields?: FieldsResolver /** The field mapping to use for this source */;
}
export type MetricAliasResolver = Resolver<string>;
export type LogAliasResolver = Resolver<string>;
export type FieldsResolver = Resolver<InfraSourceFields>;
}
/** A mapping of semantic fields to their document counterparts */
export namespace InfraSourceFieldsResolvers {
export interface Resolvers {
container?: ContainerResolver /** The field to identify a container by */;
host?: HostResolver /** The fields to identify a host by */;
message?: MessageResolver /** The fields that may contain the log event message. The first field found win. */;
pod?: PodResolver /** The field to identify a pod by */;
tiebreaker?: TiebreakerResolver /** The field to use as a tiebreaker for log events that have identical timestamps */;
timestamp?: TimestampResolver /** The field to use as a timestamp for metrics and logs */;
}
export type ContainerResolver = Resolver<string>;
export type HostResolver = Resolver<string>;
export type MessageResolver = Resolver<string[]>;
export type PodResolver = Resolver<string>;
export type TiebreakerResolver = Resolver<string>;
export type TimestampResolver = Resolver<string>;
}
/** The status of an infrastructure data source */
export namespace InfraSourceStatusResolvers {
export interface Resolvers {
metricAliasExists?: MetricAliasExistsResolver /** Whether the configured metric alias exists */;
logAliasExists?: LogAliasExistsResolver /** Whether the configured log alias exists */;
metricIndicesExist?: MetricIndicesExistResolver /** Whether the configured alias or wildcard pattern resolve to any metric indices */;
logIndicesExist?: LogIndicesExistResolver /** Whether the configured alias or wildcard pattern resolve to any log indices */;
metricIndices?: MetricIndicesResolver /** The list of indices in the metric alias */;
logIndices?: LogIndicesResolver /** The list of indices in the log alias */;
indexFields?: IndexFieldsResolver /** The list of fields defined in the index mappings */;
}
export type MetricAliasExistsResolver = Resolver<boolean>;
export type LogAliasExistsResolver = Resolver<boolean>;
export type MetricIndicesExistResolver = Resolver<boolean>;
export type LogIndicesExistResolver = Resolver<boolean>;
export type MetricIndicesResolver = Resolver<string[]>;
export type LogIndicesResolver = Resolver<string[]>;
export type IndexFieldsResolver = Resolver<InfraIndexField[], IndexFieldsArgs>;
export interface IndexFieldsArgs {
indexType?: InfraIndexType | null;
}
}
/** A descriptor of a field in an index */
export namespace InfraIndexFieldResolvers {
export interface Resolvers {
name?: NameResolver /** The name of the field */;
type?: TypeResolver /** The type of the field's values as recognized by Kibana */;
searchable?: SearchableResolver /** Whether the field's values can be efficiently searched for */;
aggregatable?: AggregatableResolver /** Whether the field's values can be aggregated */;
}
export type NameResolver = Resolver<string>;
export type TypeResolver = Resolver<string>;
export type SearchableResolver = Resolver<boolean>;
export type AggregatableResolver = Resolver<boolean>;
}
/** One metadata entry for a node. */
export namespace InfraNodeMetadataResolvers {
export interface Resolvers {
name?: NameResolver;
source?: SourceResolver;
}
export type NameResolver = Resolver<string>;
export type SourceResolver = Resolver<string>;
}
/** A consecutive sequence of log entries */
export namespace InfraLogEntryIntervalResolvers {
export interface Resolvers {
start?: StartResolver /** The key corresponding to the start of the interval covered by the entries */;
end?: EndResolver /** The key corresponding to the end of the interval covered by the entries */;
hasMoreBefore?: HasMoreBeforeResolver /** Whether there are more log entries available before the start */;
hasMoreAfter?: HasMoreAfterResolver /** Whether there are more log entries available after the end */;
filterQuery?: FilterQueryResolver /** The query the log entries were filtered by */;
highlightQuery?: HighlightQueryResolver /** The query the log entries were highlighted with */;
entries?: EntriesResolver /** A list of the log entries */;
}
export type StartResolver = Resolver<InfraTimeKey | null>;
export type EndResolver = Resolver<InfraTimeKey | null>;
export type HasMoreBeforeResolver = Resolver<boolean>;
export type HasMoreAfterResolver = Resolver<boolean>;
export type FilterQueryResolver = Resolver<string | null>;
export type HighlightQueryResolver = Resolver<string | null>;
export type EntriesResolver = Resolver<InfraLogEntry[]>;
}
/** A representation of the log entry's position in the event stream */
export namespace InfraTimeKeyResolvers {
export interface Resolvers {
time?: TimeResolver /** The timestamp of the event that the log entry corresponds to */;
tiebreaker?: TiebreakerResolver /** The tiebreaker that disambiguates events with the same timestamp */;
}
export type TimeResolver = Resolver<number>;
export type TiebreakerResolver = Resolver<number>;
}
/** A log entry */
export namespace InfraLogEntryResolvers {
export interface Resolvers {
key?: KeyResolver /** A unique representation of the log entry's position in the event stream */;
gid?: GidResolver /** The log entry's id */;
source?: SourceResolver /** The source id */;
message?: MessageResolver /** A list of the formatted log entry segments */;
}
export type KeyResolver = Resolver<InfraTimeKey>;
export type GidResolver = Resolver<string>;
export type SourceResolver = Resolver<string>;
export type MessageResolver = Resolver<InfraLogMessageSegment[]>;
}
/** A segment of the log entry message that was derived from a field */
export namespace InfraLogMessageFieldSegmentResolvers {
export interface Resolvers {
field?: FieldResolver /** The field the segment was derived from */;
value?: ValueResolver /** The segment's message */;
highlights?: HighlightsResolver /** A list of highlighted substrings of the value */;
}
export type FieldResolver = Resolver<string>;
export type ValueResolver = Resolver<string>;
export type HighlightsResolver = Resolver<string[]>;
}
/** A segment of the log entry message that was derived from a field */
export namespace InfraLogMessageConstantSegmentResolvers {
export interface Resolvers {
constant?: ConstantResolver /** The segment's message */;
}
export type ConstantResolver = Resolver<string>;
}
/** A consecutive sequence of log summary buckets */
export namespace InfraLogSummaryIntervalResolvers {
export interface Resolvers {
start?: StartResolver /** The millisecond timestamp corresponding to the start of the interval covered by the summary */;
end?: EndResolver /** The millisecond timestamp corresponding to the end of the interval covered by the summary */;
filterQuery?: FilterQueryResolver /** The query the log entries were filtered by */;
buckets?: BucketsResolver /** A list of the log entries */;
}
export type StartResolver = Resolver<number | null>;
export type EndResolver = Resolver<number | null>;
export type FilterQueryResolver = Resolver<string | null>;
export type BucketsResolver = Resolver<InfraLogSummaryBucket[]>;
}
/** A log summary bucket */
export namespace InfraLogSummaryBucketResolvers {
export interface Resolvers {
start?: StartResolver /** The start timestamp of the bucket */;
end?: EndResolver /** The end timestamp of the bucket */;
entriesCount?: EntriesCountResolver /** The number of entries inside the bucket */;
}
export type StartResolver = Resolver<number>;
export type EndResolver = Resolver<number>;
export type EntriesCountResolver = Resolver<number>;
}
export namespace InfraResponseResolvers {
export interface Resolvers {
nodes?: NodesResolver;
}
export type NodesResolver = Resolver<InfraNode[], NodesArgs>;
export interface NodesArgs {
path: InfraPathInput[];
metric: InfraMetricInput;
}
}
export namespace InfraNodeResolvers {
export interface Resolvers {
path?: PathResolver;
metric?: MetricResolver;
}
export type PathResolver = Resolver<InfraNodePath[]>;
export type MetricResolver = Resolver<InfraNodeMetric>;
}
export namespace InfraNodePathResolvers {
export interface Resolvers {
value?: ValueResolver;
}
export type ValueResolver = Resolver<string>;
}
export namespace InfraNodeMetricResolvers {
export interface Resolvers {
name?: NameResolver;
value?: ValueResolver;
}
export type NameResolver = Resolver<InfraMetricType>;
export type ValueResolver = Resolver<number>;
}
export namespace InfraMetricDataResolvers {
export interface Resolvers {
id?: IdResolver;
series?: SeriesResolver;
}
export type IdResolver = Resolver<InfraMetric | null>;
export type SeriesResolver = Resolver<InfraDataSeries[]>;
}
export namespace InfraDataSeriesResolvers {
export interface Resolvers {
id?: IdResolver;
data?: DataResolver;
}
export type IdResolver = Resolver<string>;
export type DataResolver = Resolver<InfraDataPoint[]>;
}
export namespace InfraDataPointResolvers {
export interface Resolvers {
timestamp?: TimestampResolver;
value?: ValueResolver;
}
export type TimestampResolver = Resolver<number>;
export type ValueResolver = Resolver<number | null>;
}
export interface InfraTimeKeyInput {
time: number;
tiebreaker: number;
}
export interface InfraTimerangeInput {
interval: string /** The interval string to use for last bucket. The format is '{value}{unit}'. For example '5m' would return the metrics for the last 5 minutes of the timespan. */;
to: number /** The end of the timerange */;
from: number /** The beginning of the timerange */;
}
export interface InfraPathInput {
type: InfraPathType /** The type of path */;
label?:
| string
| null /** The label to use in the results for the group by for the terms group by */;
field?:
| string
| null /** The field to group by from a terms aggregation, this is ignored by the filter type */;
filters?: InfraPathFilterInput[] | null /** The fitlers for the filter group by */;
}
/** A group by filter */
export interface InfraPathFilterInput {
label: string /** The label for the filter, this will be used as the group name in the final results */;
query: string /** The query string query */;
}
export interface InfraMetricInput {
type: InfraMetricType /** The type of metric */;
}
export interface SourceQueryArgs {
id: string /** The id of the source */;
}
export interface MetadataByNodeInfraSourceArgs {
nodeName: string;
nodeType: InfraNodeType;
}
export interface LogEntriesAroundInfraSourceArgs {
key: InfraTimeKeyInput /** The sort key that corresponds to the point in time */;
countBefore?: number | null /** The maximum number of preceding to return */;
countAfter?: number | null /** The maximum number of following to return */;
filterQuery?: string | null /** The query to filter the log entries by */;
highlightQuery?: string | null /** The query to highlight the log entries with */;
}
export interface LogEntriesBetweenInfraSourceArgs {
startKey: InfraTimeKeyInput /** The sort key that corresponds to the start of the interval */;
endKey: InfraTimeKeyInput /** The sort key that corresponds to the end of the interval */;
filterQuery?: string | null /** The query to filter the log entries by */;
highlightQuery?: string | null /** The query to highlight the log entries with */;
}
export interface LogSummaryBetweenInfraSourceArgs {
start: number /** The millisecond timestamp that corresponds to the start of the interval */;
end: number /** The millisecond timestamp that corresponds to the end of the interval */;
bucketSize: number /** The size of each bucket in milliseconds */;
filterQuery?: string | null /** The query to filter the log entries by */;
}
export interface MapInfraSourceArgs {
timerange: InfraTimerangeInput;
filterQuery?: string | null;
}
export interface MetricsInfraSourceArgs {
nodeId: string;
nodeType: InfraNodeType;
timerange: InfraTimerangeInput;
metrics: InfraMetric[];
}
export interface IndexFieldsInfraSourceStatusArgs {
indexType?: InfraIndexType | null;
}
export interface NodesInfraResponseArgs {
path: InfraPathInput[];
metric: InfraMetricInput;
}
export enum InfraIndexType {
ANY = 'ANY',
LOGS = 'LOGS',
METRICS = 'METRICS',
}
export enum InfraNodeType {
pod = 'pod',
container = 'container',
host = 'host',
}
export enum InfraPathType {
terms = 'terms',
filters = 'filters',
hosts = 'hosts',
pods = 'pods',
containers = 'containers',
}
export enum InfraMetricType {
count = 'count',
cpu = 'cpu',
load = 'load',
memory = 'memory',
tx = 'tx',
rx = 'rx',
logRate = 'logRate',
}
export enum InfraMetric {
hostSystemOverview = 'hostSystemOverview',
hostCpuUsage = 'hostCpuUsage',
hostFilesystem = 'hostFilesystem',
hostK8sOverview = 'hostK8sOverview',
hostK8sCpuCap = 'hostK8sCpuCap',
hostK8sDiskCap = 'hostK8sDiskCap',
hostK8sMemoryCap = 'hostK8sMemoryCap',
hostK8sPodCap = 'hostK8sPodCap',
hostLoad = 'hostLoad',
hostMemoryUsage = 'hostMemoryUsage',
hostNetworkTraffic = 'hostNetworkTraffic',
podOverview = 'podOverview',
podCpuUsage = 'podCpuUsage',
podMemoryUsage = 'podMemoryUsage',
podLogUsage = 'podLogUsage',
podNetworkTraffic = 'podNetworkTraffic',
containerOverview = 'containerOverview',
containerCpuKernel = 'containerCpuKernel',
containerCpuUsage = 'containerCpuUsage',
containerDiskIOOps = 'containerDiskIOOps',
containerDiskIOBytes = 'containerDiskIOBytes',
containerMemory = 'containerMemory',
containerNetworkTraffic = 'containerNetworkTraffic',
nginxHits = 'nginxHits',
nginxRequestRate = 'nginxRequestRate',
nginxActiveConnections = 'nginxActiveConnections',
nginxRequestsPerConnection = 'nginxRequestsPerConnection',
}
export enum InfraOperator {
gt = 'gt',
gte = 'gte',
lt = 'lt',
lte = 'lte',
eq = 'eq',
}
/** A segment of the log entry message */
export type InfraLogMessageSegment = InfraLogMessageFieldSegment | InfraLogMessageConstantSegment;
export namespace MetadataQuery {
export type Variables = {
sourceId: string;
nodeId: string;
nodeType: InfraNodeType;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
metadataByNode: (MetadataByNode | null)[];
};
export type MetadataByNode = {
__typename?: 'InfraNodeMetadata';
name: string;
source: string;
};
}
export namespace MetricsQuery {
export type Variables = {
sourceId: string;
timerange: InfraTimerangeInput;
metrics: InfraMetric[];
nodeId: string;
nodeType: InfraNodeType;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
metrics: Metrics[];
};
export type Metrics = {
__typename?: 'InfraMetricData';
id?: InfraMetric | null;
series: Series[];
};
export type Series = {
__typename?: 'InfraDataSeries';
id: string;
data: Data[];
};
export type Data = {
__typename?: 'InfraDataPoint';
timestamp: number;
value?: number | null;
};
}
export namespace WaffleNodesQuery {
export type Variables = {
sourceId: string;
timerange: InfraTimerangeInput;
filterQuery?: string | null;
metric: InfraMetricInput;
path: InfraPathInput[];
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
map?: Map | null;
};
export type Map = {
__typename?: 'InfraResponse';
nodes: Nodes[];
};
export type Nodes = {
__typename?: 'InfraNode';
path: Path[];
metric: Metric;
};
export type Path = {
__typename?: 'InfraNodePath';
value: string;
};
export type Metric = {
__typename?: 'InfraNodeMetric';
name: InfraMetricType;
value: number;
};
}
export namespace SourceQuery {
export type Variables = {
sourceId?: string | null;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
configuration: Configuration;
status: Status;
};
export type Configuration = {
__typename?: 'InfraSourceConfiguration';
metricAlias: string;
logAlias: string;
fields: Fields;
};
export type Fields = {
__typename?: 'InfraSourceFields';
container: string;
host: string;
pod: string;
};
export type Status = {
__typename?: 'InfraSourceStatus';
indexFields: IndexFields[];
logIndicesExist: boolean;
metricIndicesExist: boolean;
};
export type IndexFields = {
__typename?: 'InfraIndexField';
name: string;
type: string;
searchable: boolean;
aggregatable: boolean;
};
}
export namespace LogEntries {
export type Variables = {
sourceId?: string | null;
timeKey: InfraTimeKeyInput;
countBefore?: number | null;
countAfter?: number | null;
filterQuery?: string | null;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
logEntriesAround: LogEntriesAround;
};
export type LogEntriesAround = {
__typename?: 'InfraLogEntryInterval';
start?: Start | null;
end?: End | null;
hasMoreBefore: boolean;
hasMoreAfter: boolean;
entries: Entries[];
};
export type Start = InfraTimeKeyFields.Fragment;
export type End = InfraTimeKeyFields.Fragment;
export type Entries = {
__typename?: 'InfraLogEntry';
gid: string;
key: Key;
message: Message[];
};
export type Key = {
__typename?: 'InfraTimeKey';
time: number;
tiebreaker: number;
};
export type Message =
| InfraLogMessageFieldSegmentInlineFragment
| InfraLogMessageConstantSegmentInlineFragment;
export type InfraLogMessageFieldSegmentInlineFragment = {
__typename?: 'InfraLogMessageFieldSegment';
field: string;
value: string;
};
export type InfraLogMessageConstantSegmentInlineFragment = {
__typename?: 'InfraLogMessageConstantSegment';
constant: string;
};
}
export namespace LogSummary {
export type Variables = {
sourceId?: string | null;
start: number;
end: number;
bucketSize: number;
filterQuery?: string | null;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
logSummaryBetween: LogSummaryBetween;
};
export type LogSummaryBetween = {
__typename?: 'InfraLogSummaryInterval';
start?: number | null;
end?: number | null;
buckets: Buckets[];
};
export type Buckets = {
__typename?: 'InfraLogSummaryBucket';
start: number;
end: number;
entriesCount: number;
};
}
export namespace InfraTimeKeyFields {
export type Fragment = {
__typename?: 'InfraTimeKey';
time: number;
tiebreaker: number;
};
}

2
x-pack/plugins/infra/public/components/metrics/index.tsx
View file

@ -8,7 +8,7 @@ import { EuiPageContentBody, EuiTitle } from '@elastic/eui';
import { FormattedMessage, InjectedIntl, injectI18n } from '@kbn/i18n/react';
import React from 'react';
import { InfraMetricData } from '../../../common/graphql/types';
import { InfraMetricData } from '../../graphql/types';
import { InfraMetricLayout, InfraMetricLayoutSection } from '../../pages/metrics/layouts/types';
import { metricTimeActions } from '../../store';
import { InfraLoadingPanel } from '../loading';

2
x-pack/plugins/infra/public/components/metrics/section.tsx
View file

@ -5,7 +5,7 @@
*/
import React from 'react';
import { InfraMetricData } from '../../../common/graphql/types';
import { InfraMetricData } from '../../graphql/types';
import { InfraMetricLayoutSection } from '../../pages/metrics/layouts/types';
import { metricTimeActions } from '../../store';
import { sections } from './sections';

2
x-pack/plugins/infra/public/components/metrics/sections/chart_section.tsx
View file

@ -21,7 +21,7 @@ import Color from 'color';
import { get } from 'lodash';
import moment from 'moment';
import React, { ReactText } from 'react';
import { InfraDataSeries, InfraMetricData } from '../../../../common/graphql/types';
import { InfraDataSeries, InfraMetricData } from '../../../graphql/types';
import { InfraFormatter, InfraFormatterType } from '../../../lib/lib';
import {
InfraMetricLayoutSection,

2
x-pack/plugins/infra/public/components/metrics/sections/gauges_section.tsx
View file

@ -16,7 +16,7 @@ import {
import { get, last, max } from 'lodash';
import React, { ReactText } from 'react';
import styled from 'styled-components';
import { InfraMetricData } from '../../../../common/graphql/types';
import { InfraMetricData } from '../../../graphql/types';
import { InfraFormatterType } from '../../../lib/lib';
import { InfraMetricLayoutSection } from '../../../pages/metrics/layouts/types';
import { createFormatter } from '../../../utils/formatters';

4
x-pack/plugins/infra/public/components/waffle/group_name.tsx
View file

@ -6,7 +6,7 @@
import { EuiLink, EuiToolTip } from '@elastic/eui';
import React from 'react';
import styled from 'styled-components';
import { InfraPathType } from '../../../common/graphql/types';
import { InfraPathType } from '../../graphql/types';
import { InfraWaffleMapGroup, InfraWaffleMapOptions } from '../../lib/lib';
interface Props {
@ -62,7 +62,7 @@ const GroupNameContainer = styled.div`
position: relative;
text-align: center
font-size: 16px;
margin-bottom: 5px;
margin-bottom: 5px;
top: 20px;
display: flex;
justify-content: center;

2
x-pack/plugins/infra/public/components/waffle/group_of_groups.tsx
View file

@ -6,7 +6,7 @@
import React from 'react';
import styled from 'styled-components';
import { InfraNodeType, InfraTimerangeInput } from '../../../common/graphql/types';
import { InfraNodeType, InfraTimerangeInput } from '../../graphql/types';
import {
InfraWaffleMapBounds,
InfraWaffleMapGroupOfGroups,

2
x-pack/plugins/infra/public/components/waffle/group_of_nodes.tsx
View file

@ -6,7 +6,7 @@
import React from 'react';
import styled from 'styled-components';
import { InfraNodeType, InfraTimerangeInput } from '../../../common/graphql/types';
import { InfraNodeType, InfraTimerangeInput } from '../../graphql/types';
import {
InfraWaffleMapBounds,
InfraWaffleMapGroupOfNodes,

3
x-pack/plugins/infra/public/components/waffle/index.tsx
View file

@ -8,11 +8,12 @@ import { FormattedMessage, InjectedIntl, injectI18n } from '@kbn/i18n/react';
import { get, max, min } from 'lodash';
import React from 'react';
import styled from 'styled-components';
import { InfraMetricType, InfraNodeType, InfraTimerangeInput } from '../../../common/graphql/types';
import {
isWaffleMapGroupWithGroups,
isWaffleMapGroupWithNodes,
} from '../../containers/waffle/type_guards';
import { InfraMetricType, InfraNodeType, InfraTimerangeInput } from '../../graphql/types';
import {
InfraFormatterType,
InfraWaffleData,

3
x-pack/plugins/infra/public/components/waffle/node.tsx
View file

@ -9,8 +9,9 @@ import moment from 'moment';
import { darken, readableColor } from 'polished';
import React from 'react';
import styled from 'styled-components';
import { InfraTimerangeInput } from 'x-pack/plugins/infra/common/graphql/types';
import { InfraNodeType } from '../../../server/lib/adapters/nodes';
import { InfraTimerangeInput } from '../../graphql/types';
import { InfraWaffleMapBounds, InfraWaffleMapNode, InfraWaffleMapOptions } from '../../lib/lib';
import { colorFromValue } from './lib/color_from_value';
import { NodeContextMenu } from './node_context_menu';

2
x-pack/plugins/infra/public/components/waffle/node_context_menu.tsx
View file

@ -8,7 +8,7 @@ import { EuiContextMenu, EuiContextMenuPanelDescriptor, EuiPopover } from '@elas
import { InjectedIntl, injectI18n } from '@kbn/i18n/react';
import React from 'react';
import { InfraNodeType, InfraTimerangeInput } from '../../../common/graphql/types';
import { InfraNodeType, InfraTimerangeInput } from '../../graphql/types';
import { InfraWaffleMapNode, InfraWaffleMapOptions } from '../../lib/lib';
import { getNodeDetailUrl, getNodeLogsUrl } from '../../pages/link_to';

2
x-pack/plugins/infra/public/components/waffle/waffle_group_by_controls.tsx
View file

@ -14,7 +14,7 @@ import {
} from '@elastic/eui';
import { FormattedMessage, InjectedIntl, injectI18n } from '@kbn/i18n/react';
import React from 'react';
import { InfraNodeType, InfraPathInput, InfraPathType } from '../../../common/graphql/types';
import { InfraNodeType, InfraPathInput, InfraPathType } from '../../graphql/types';
interface Props {
nodeType: InfraNodeType;

4
x-pack/plugins/infra/public/components/waffle/waffle_metric_controls.tsx
View file

@ -13,7 +13,9 @@ import {
} from '@elastic/eui';
import { FormattedMessage, InjectedIntl, injectI18n } from '@kbn/i18n/react';
import React from 'react';
import { InfraMetricInput, InfraMetricType, InfraNodeType } from '../../../common/graphql/types';
import { InfraMetricInput, InfraMetricType, InfraNodeType } from '../../graphql/types';
interface Props {
nodeType: InfraNodeType;
metric: InfraMetricInput;

2
x-pack/plugins/infra/public/components/waffle/waffle_node_type_switcher.tsx
View file

@ -12,7 +12,7 @@ import {
InfraMetricType,
InfraNodeType,
InfraPathInput,
} from '../../../common/graphql/types';
} from '../../graphql/types';
interface Props {
nodeType: InfraNodeType;

12
x-pack/plugins/infra/public/containers/host/index.ts
View file

@ -1,12 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
import { AllHosts } from './with_all_hosts';
export { withAllHosts } from './with_all_hosts';
export const hostQueries = {
AllHosts,
};

30
x-pack/plugins/infra/public/containers/host/with_all_hosts.ts
View file

@ -1,30 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
// import { graphql } from 'react-apollo';
// import gql from 'graphql-tag';
// import { GetAllHosts } from '../../../common/graphql/types';
// type ChildProps = {
// hosts: GetAllHosts.Query['hosts'];
// };
export const AllHosts = null;
export const withAllHosts: any = (wrappedComponent: any) => wrappedComponent;
// export const withAllHosts = graphql<
// {},
// GetAllHosts.Query,
// GetAllHosts.Variables,
// ChildProps
// >(AllHosts, {
// props: ({ data, ownProps }) => {
// return {
// hosts: data && data.hosts ? data.hosts : [],
// ...ownProps,
// };
// },
// });

4
x-pack/plugins/infra/public/containers/metadata/with_metadata.tsx
View file

@ -5,10 +5,10 @@
*/
import _ from 'lodash';
import React from 'react';
import { Query } from 'react-apollo';
import { InfraNodeType, MetadataQuery } from '../../../common/graphql/types';
import { InfraNodeType, MetadataQuery } from '../../graphql/types';
import { InfraMetricLayout } from '../../pages/metrics/layouts/types';
import { metadataQuery } from './metadata.gql_query';

2
x-pack/plugins/infra/public/containers/metrics/with_metrics.tsx
View file

@ -12,7 +12,7 @@ import {
InfraNodeType,
InfraTimerangeInput,
MetricsQuery,
} from '../../../common/graphql/types';
} from '../../graphql/types';
import { InfraMetricLayout } from '../../pages/metrics/layouts/types';
import { metricsQuery } from './metrics.gql_query';

3
x-pack/plugins/infra/public/containers/waffle/nodes_to_wafflemap.ts
View file

@ -6,7 +6,8 @@
import { i18n } from '@kbn/i18n';
import { first, last } from 'lodash';
import { InfraNode, InfraNodePath } from '../../../common/graphql/types';
import { InfraNode, InfraNodePath } from '../../graphql/types';
import {
InfraWaffleMapGroup,
InfraWaffleMapGroupOfGroups,

4
x-pack/plugins/infra/public/containers/waffle/with_waffle_nodes.tsx
View file

@ -9,12 +9,12 @@ import { Query } from 'react-apollo';
import {
InfraMetricInput,
InfraNodeType,
InfraPathInput,
InfraPathType,
InfraTimerangeInput,
WaffleNodesQuery,
} from '../../../common/graphql/types';
import { InfraNodeType } from '../../../server/lib/adapters/nodes';
} from '../../graphql/types';
import { InfraWaffleMapGroup } from '../../lib/lib';
import { nodesToWaffleMap } from './nodes_to_wafflemap';
import { waffleNodesQuery } from './waffle_nodes.gql_query';

9
x-pack/plugins/infra/public/containers/waffle/with_waffle_options.tsx
View file

@ -7,8 +7,13 @@
import React from 'react';
import { connect } from 'react-redux';
import { createSelector } from 'reselect';
import { InfraMetricInput, InfraMetricType, InfraPathType } from '../../../common/graphql/types';
import { InfraNodeType } from '../../../server/lib/adapters/nodes';
import {
InfraMetricInput,
InfraMetricType,
InfraNodeType,
InfraPathType,
} from '../../graphql/types';
import { State, waffleOptionsActions, waffleOptionsSelectors } from '../../store';
import { asChildFunctionRenderer } from '../../utils/typed_react';
import { bindPlainActionCreators } from '../../utils/typed_redux';

2
x-pack/plugins/infra/public/containers/with_options.tsx
View file

@ -7,7 +7,7 @@
import moment from 'moment';
import React from 'react';
import { InfraMetricType, InfraPathType } from '../../common/graphql/types';
import { InfraMetricType, InfraPathType } from '../graphql/types';
import {
InfraFormatterType,
InfraOptions,

2
x-pack/plugins/infra/public/containers/with_source/with_source.tsx
View file

@ -12,7 +12,7 @@ import { createSelector } from 'reselect';
import { StaticIndexPattern } from 'ui/index_patterns';
import { memoizeLast } from 'ui/utils/memoize';
import { SourceQuery } from '../../../common/graphql/types';
import { SourceQuery } from '../../graphql/types';
import {
createStatusActions,
createStatusSelectors,

105
x-pack/plugins/infra/common/graphql/introspection.json → x-pack/plugins/infra/public/graphql/introspection.json
View file

@ -61,8 +61,7 @@
{
"kind": "SCALAR",
"name": "ID",
"description":
"The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"4\"`) or integer (such as `4`) input value will be accepted as an ID.",
"description": "The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"4\"`) or integer (such as `4`) input value will be accepted as an ID.",
"fields": null,
"inputFields": null,
"interfaces": null,
@ -245,8 +244,7 @@
"args": [
{
"name": "start",
"description":
"The millisecond timestamp that corresponds to the start of the interval",
"description": "The millisecond timestamp that corresponds to the start of the interval",
"type": {
"kind": "NON_NULL",
"name": null,
@ -256,8 +254,7 @@
},
{
"name": "end",
"description":
"The millisecond timestamp that corresponds to the end of the interval",
"description": "The millisecond timestamp that corresponds to the end of the interval",
"type": {
"kind": "NON_NULL",
"name": null,
@ -448,8 +445,7 @@
{
"kind": "SCALAR",
"name": "String",
"description":
"The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.",
"description": "The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.",
"fields": null,
"inputFields": null,
"interfaces": null,
@ -487,8 +483,7 @@
},
{
"name": "message",
"description":
"The fields that may contain the log event message. The first field found win.",
"description": "The fields that may contain the log event message. The first field found win.",
"args": [],
"type": {
"kind": "NON_NULL",
@ -520,8 +515,7 @@
},
{
"name": "tiebreaker",
"description":
"The field to use as a tiebreaker for log events that have identical timestamps",
"description": "The field to use as a tiebreaker for log events that have identical timestamps",
"args": [],
"type": {
"kind": "NON_NULL",
@ -580,8 +574,7 @@
},
{
"name": "metricIndicesExist",
"description":
"Whether the configured alias or wildcard pattern resolve to any metric indices",
"description": "Whether the configured alias or wildcard pattern resolve to any metric indices",
"args": [],
"type": {
"kind": "NON_NULL",
@ -593,8 +586,7 @@
},
{
"name": "logIndicesExist",
"description":
"Whether the configured alias or wildcard pattern resolve to any log indices",
"description": "Whether the configured alias or wildcard pattern resolve to any log indices",
"args": [],
"type": {
"kind": "NON_NULL",
@ -848,8 +840,7 @@
{
"kind": "SCALAR",
"name": "Float",
"description":
"The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ",
"description": "The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ",
"fields": null,
"inputFields": null,
"interfaces": null,
@ -859,8 +850,7 @@
{
"kind": "SCALAR",
"name": "Int",
"description":
"The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1. ",
"description": "The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1. ",
"fields": null,
"inputFields": null,
"interfaces": null,
@ -874,8 +864,7 @@
"fields": [
{
"name": "start",
"description":
"The key corresponding to the start of the interval covered by the entries",
"description": "The key corresponding to the start of the interval covered by the entries",
"args": [],
"type": { "kind": "OBJECT", "name": "InfraTimeKey", "ofType": null },
"isDeprecated": false,
@ -883,8 +872,7 @@
},
{
"name": "end",
"description":
"The key corresponding to the end of the interval covered by the entries",
"description": "The key corresponding to the end of the interval covered by the entries",
"args": [],
"type": { "kind": "OBJECT", "name": "InfraTimeKey", "ofType": null },
"isDeprecated": false,
@ -998,8 +986,7 @@
"fields": [
{
"name": "key",
"description":
"A unique representation of the log entry's position in the event stream",
"description": "A unique representation of the log entry's position in the event stream",
"args": [],
"type": {
"kind": "NON_NULL",
@ -1157,8 +1144,7 @@
"fields": [
{
"name": "start",
"description":
"The millisecond timestamp corresponding to the start of the interval covered by the summary",
"description": "The millisecond timestamp corresponding to the start of the interval covered by the summary",
"args": [],
"type": { "kind": "SCALAR", "name": "Float", "ofType": null },
"isDeprecated": false,
@ -1166,8 +1152,7 @@
},
{
"name": "end",
"description":
"The millisecond timestamp corresponding to the end of the interval covered by the summary",
"description": "The millisecond timestamp corresponding to the end of the interval covered by the summary",
"args": [],
"type": { "kind": "SCALAR", "name": "Float", "ofType": null },
"isDeprecated": false,
@ -1262,8 +1247,7 @@
"inputFields": [
{
"name": "interval",
"description":
"The interval string to use for last bucket. The format is '{value}{unit}'. For example '5m' would return the metrics for the last 5 minutes of the timespan.",
"description": "The interval string to use for last bucket. The format is '{value}{unit}'. For example '5m' would return the metrics for the last 5 minutes of the timespan.",
"type": {
"kind": "NON_NULL",
"name": null,
@ -1374,15 +1358,13 @@
},
{
"name": "label",
"description":
"The label to use in the results for the group by for the terms group by",
"description": "The label to use in the results for the group by for the terms group by",
"type": { "kind": "SCALAR", "name": "String", "ofType": null },
"defaultValue": null
},
{
"name": "field",
"description":
"The field to group by from a terms aggregation, this is ignored by the filter type",
"description": "The field to group by from a terms aggregation, this is ignored by the filter type",
"type": { "kind": "SCALAR", "name": "String", "ofType": null },
"defaultValue": null
},
@ -1439,8 +1421,7 @@
"inputFields": [
{
"name": "label",
"description":
"The label for the filter, this will be used as the group name in the final results",
"description": "The label for the filter, this will be used as the group name in the final results",
"type": {
"kind": "NON_NULL",
"name": null,
@ -1892,8 +1873,7 @@
{
"kind": "OBJECT",
"name": "__Schema",
"description":
"A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.",
"description": "A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.",
"fields": [
{
"name": "types",
@ -1929,8 +1909,7 @@
},
{
"name": "mutationType",
"description":
"If this server supports mutation, the type that mutation operations will be rooted at.",
"description": "If this server supports mutation, the type that mutation operations will be rooted at.",
"args": [],
"type": { "kind": "OBJECT", "name": "__Type", "ofType": null },
"isDeprecated": false,
@ -1938,8 +1917,7 @@
},
{
"name": "subscriptionType",
"description":
"If this server support subscription, the type that subscription operations will be rooted at.",
"description": "If this server support subscription, the type that subscription operations will be rooted at.",
"args": [],
"type": { "kind": "OBJECT", "name": "__Type", "ofType": null },
"isDeprecated": false,
@ -1974,8 +1952,7 @@
{
"kind": "OBJECT",
"name": "__Type",
"description":
"The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name and description, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.",
"description": "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name and description, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.",
"fields": [
{
"name": "kind",
@ -2129,15 +2106,13 @@
},
{
"name": "OBJECT",
"description":
"Indicates this type is an object. `fields` and `interfaces` are valid fields.",
"description": "Indicates this type is an object. `fields` and `interfaces` are valid fields.",
"isDeprecated": false,
"deprecationReason": null
},
{
"name": "INTERFACE",
"description":
"Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.",
"description": "Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.",
"isDeprecated": false,
"deprecationReason": null
},
@ -2155,8 +2130,7 @@
},
{
"name": "INPUT_OBJECT",
"description":
"Indicates this type is an input object. `inputFields` is a valid field.",
"description": "Indicates this type is an input object. `inputFields` is a valid field.",
"isDeprecated": false,
"deprecationReason": null
},
@ -2178,8 +2152,7 @@
{
"kind": "OBJECT",
"name": "__Field",
"description":
"Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.",
"description": "Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.",
"fields": [
{
"name": "name",
@ -2262,8 +2235,7 @@
{
"kind": "OBJECT",
"name": "__InputValue",
"description":
"Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.",
"description": "Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.",
"fields": [
{
"name": "name",
@ -2299,8 +2271,7 @@
},
{
"name": "defaultValue",
"description":
"A GraphQL-formatted string representing the default value for this input value.",
"description": "A GraphQL-formatted string representing the default value for this input value.",
"args": [],
"type": { "kind": "SCALAR", "name": "String", "ofType": null },
"isDeprecated": false,
@ -2315,8 +2286,7 @@
{
"kind": "OBJECT",
"name": "__EnumValue",
"description":
"One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string.",
"description": "One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string.",
"fields": [
{
"name": "name",
@ -2367,8 +2337,7 @@
{
"kind": "OBJECT",
"name": "__Directive",
"description":
"A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.\n\nIn some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.",
"description": "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.\n\nIn some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.",
"fields": [
{
"name": "name",
@ -2475,8 +2444,7 @@
{
"kind": "ENUM",
"name": "__DirectiveLocation",
"description":
"A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies.",
"description": "A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies.",
"fields": null,
"inputFields": null,
"interfaces": null,
@ -2612,8 +2580,7 @@
"directives": [
{
"name": "skip",
"description":
"Directs the executor to skip this field or fragment when the `if` argument is true.",
"description": "Directs the executor to skip this field or fragment when the `if` argument is true.",
"locations": ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
"args": [
{
@ -2630,8 +2597,7 @@
},
{
"name": "include",
"description":
"Directs the executor to include this field or fragment only when the `if` argument is true.",
"description": "Directs the executor to include this field or fragment only when the `if` argument is true.",
"locations": ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
"args": [
{
@ -2653,8 +2619,7 @@
"args": [
{
"name": "reason",
"description":
"Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted in [Markdown](https://daringfireball.net/projects/markdown/).",
"description": "Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted in [Markdown](https://daringfireball.net/projects/markdown/).",
"type": { "kind": "SCALAR", "name": "String", "ofType": null },
"defaultValue": "\"No longer supported\""
}

725
x-pack/plugins/infra/public/graphql/types.ts Normal file
View file

@ -0,0 +1,725 @@
/* tslint:disable */
// ====================================================
// START: Typescript template
// ====================================================
// ====================================================
// Types
// ====================================================
export interface Query {
/** Get an infrastructure data source by id */
source: InfraSource;
/** Get a list of all infrastructure data sources */
allSources: InfraSource[];
}
/** A source of infrastructure data */
export interface InfraSource {
/** The id of the source */
id: string;
/** The raw configuration of the source */
configuration: InfraSourceConfiguration;
/** The status of the source */
status: InfraSourceStatus;
/** A hierarchy of metadata entries by node */
metadataByNode: (InfraNodeMetadata | null)[];
/** A consecutive span of log entries surrounding a point in time */
logEntriesAround: InfraLogEntryInterval;
/** A consecutive span of log entries within an interval */
logEntriesBetween: InfraLogEntryInterval;
/** A consecutive span of summary buckets within an interval */
logSummaryBetween: InfraLogSummaryInterval;
/** A hierarchy of hosts, pods, containers, services or arbitrary groups */
map?: InfraResponse | null;
metrics: InfraMetricData[];
}
/** A set of configuration options for an infrastructure data source */
export interface InfraSourceConfiguration {
/** The alias to read metric data from */
metricAlias: string;
/** The alias to read log data from */
logAlias: string;
/** The field mapping to use for this source */
fields: InfraSourceFields;
}
/** A mapping of semantic fields to their document counterparts */
export interface InfraSourceFields {
/** The field to identify a container by */
container: string;
/** The fields to identify a host by */
host: string;
/** The fields that may contain the log event message. The first field found win. */
message: string[];
/** The field to identify a pod by */
pod: string;
/** The field to use as a tiebreaker for log events that have identical timestamps */
tiebreaker: string;
/** The field to use as a timestamp for metrics and logs */
timestamp: string;
}
/** The status of an infrastructure data source */
export interface InfraSourceStatus {
/** Whether the configured metric alias exists */
metricAliasExists: boolean;
/** Whether the configured log alias exists */
logAliasExists: boolean;
/** Whether the configured alias or wildcard pattern resolve to any metric indices */
metricIndicesExist: boolean;
/** Whether the configured alias or wildcard pattern resolve to any log indices */
logIndicesExist: boolean;
/** The list of indices in the metric alias */
metricIndices: string[];
/** The list of indices in the log alias */
logIndices: string[];
/** The list of fields defined in the index mappings */
indexFields: InfraIndexField[];
}
/** A descriptor of a field in an index */
export interface InfraIndexField {
/** The name of the field */
name: string;
/** The type of the field's values as recognized by Kibana */
type: string;
/** Whether the field's values can be efficiently searched for */
searchable: boolean;
/** Whether the field's values can be aggregated */
aggregatable: boolean;
}
/** One metadata entry for a node. */
export interface InfraNodeMetadata {
name: string;
source: string;
}
/** A consecutive sequence of log entries */
export interface InfraLogEntryInterval {
/** The key corresponding to the start of the interval covered by the entries */
start?: InfraTimeKey | null;
/** The key corresponding to the end of the interval covered by the entries */
end?: InfraTimeKey | null;
/** Whether there are more log entries available before the start */
hasMoreBefore: boolean;
/** Whether there are more log entries available after the end */
hasMoreAfter: boolean;
/** The query the log entries were filtered by */
filterQuery?: string | null;
/** The query the log entries were highlighted with */
highlightQuery?: string | null;
/** A list of the log entries */
entries: InfraLogEntry[];
}
/** A representation of the log entry's position in the event stream */
export interface InfraTimeKey {
/** The timestamp of the event that the log entry corresponds to */
time: number;
/** The tiebreaker that disambiguates events with the same timestamp */
tiebreaker: number;
}
/** A log entry */
export interface InfraLogEntry {
/** A unique representation of the log entry's position in the event stream */
key: InfraTimeKey;
/** The log entry's id */
gid: string;
/** The source id */
source: string;
/** A list of the formatted log entry segments */
message: InfraLogMessageSegment[];
}
/** A segment of the log entry message that was derived from a field */
export interface InfraLogMessageFieldSegment {
/** The field the segment was derived from */
field: string;
/** The segment's message */
value: string;
/** A list of highlighted substrings of the value */
highlights: string[];
}
/** A segment of the log entry message that was derived from a field */
export interface InfraLogMessageConstantSegment {
/** The segment's message */
constant: string;
}
/** A consecutive sequence of log summary buckets */
export interface InfraLogSummaryInterval {
/** The millisecond timestamp corresponding to the start of the interval covered by the summary */
start?: number | null;
/** The millisecond timestamp corresponding to the end of the interval covered by the summary */
end?: number | null;
/** The query the log entries were filtered by */
filterQuery?: string | null;
/** A list of the log entries */
buckets: InfraLogSummaryBucket[];
}
/** A log summary bucket */
export interface InfraLogSummaryBucket {
/** The start timestamp of the bucket */
start: number;
/** The end timestamp of the bucket */
end: number;
/** The number of entries inside the bucket */
entriesCount: number;
}
export interface InfraResponse {
nodes: InfraNode[];
}
export interface InfraNode {
path: InfraNodePath[];
metric: InfraNodeMetric;
}
export interface InfraNodePath {
value: string;
}
export interface InfraNodeMetric {
name: InfraMetricType;
value: number;
}
export interface InfraMetricData {
id?: InfraMetric | null;
series: InfraDataSeries[];
}
export interface InfraDataSeries {
id: string;
data: InfraDataPoint[];
}
export interface InfraDataPoint {
timestamp: number;
value?: number | null;
}
// ====================================================
// InputTypes
// ====================================================
export interface InfraTimeKeyInput {
time: number;
tiebreaker: number;
}
export interface InfraTimerangeInput {
/** The interval string to use for last bucket. The format is '{value}{unit}'. For example '5m' would return the metrics for the last 5 minutes of the timespan. */
interval: string;
/** The end of the timerange */
to: number;
/** The beginning of the timerange */
from: number;
}
export interface InfraPathInput {
/** The type of path */
type: InfraPathType;
/** The label to use in the results for the group by for the terms group by */
label?: string | null;
/** The field to group by from a terms aggregation, this is ignored by the filter type */
field?: string | null;
/** The fitlers for the filter group by */
filters?: InfraPathFilterInput[] | null;
}
/** A group by filter */
export interface InfraPathFilterInput {
/** The label for the filter, this will be used as the group name in the final results */
label: string;
/** The query string query */
query: string;
}
export interface InfraMetricInput {
/** The type of metric */
type: InfraMetricType;
}
// ====================================================
// Arguments
// ====================================================
export interface SourceQueryArgs {
/** The id of the source */
id: string;
}
export interface MetadataByNodeInfraSourceArgs {
nodeName: string;
nodeType: InfraNodeType;
}
export interface LogEntriesAroundInfraSourceArgs {
/** The sort key that corresponds to the point in time */
key: InfraTimeKeyInput;
/** The maximum number of preceding to return */
countBefore?: number | null;
/** The maximum number of following to return */
countAfter?: number | null;
/** The query to filter the log entries by */
filterQuery?: string | null;
/** The query to highlight the log entries with */
highlightQuery?: string | null;
}
export interface LogEntriesBetweenInfraSourceArgs {
/** The sort key that corresponds to the start of the interval */
startKey: InfraTimeKeyInput;
/** The sort key that corresponds to the end of the interval */
endKey: InfraTimeKeyInput;
/** The query to filter the log entries by */
filterQuery?: string | null;
/** The query to highlight the log entries with */
highlightQuery?: string | null;
}
export interface LogSummaryBetweenInfraSourceArgs {
/** The millisecond timestamp that corresponds to the start of the interval */
start: number;
/** The millisecond timestamp that corresponds to the end of the interval */
end: number;
/** The size of each bucket in milliseconds */
bucketSize: number;
/** The query to filter the log entries by */
filterQuery?: string | null;
}
export interface MapInfraSourceArgs {
timerange: InfraTimerangeInput;
filterQuery?: string | null;
}
export interface MetricsInfraSourceArgs {
nodeId: string;
nodeType: InfraNodeType;
timerange: InfraTimerangeInput;
metrics: InfraMetric[];
}
export interface IndexFieldsInfraSourceStatusArgs {
indexType?: InfraIndexType | null;
}
export interface NodesInfraResponseArgs {
path: InfraPathInput[];
metric: InfraMetricInput;
}
// ====================================================
// Enums
// ====================================================
export enum InfraIndexType {
ANY = 'ANY',
LOGS = 'LOGS',
METRICS = 'METRICS',
}
export enum InfraNodeType {
pod = 'pod',
container = 'container',
host = 'host',
}
export enum InfraPathType {
terms = 'terms',
filters = 'filters',
hosts = 'hosts',
pods = 'pods',
containers = 'containers',
}
export enum InfraMetricType {
count = 'count',
cpu = 'cpu',
load = 'load',
memory = 'memory',
tx = 'tx',
rx = 'rx',
logRate = 'logRate',
}
export enum InfraMetric {
hostSystemOverview = 'hostSystemOverview',
hostCpuUsage = 'hostCpuUsage',
hostFilesystem = 'hostFilesystem',
hostK8sOverview = 'hostK8sOverview',
hostK8sCpuCap = 'hostK8sCpuCap',
hostK8sDiskCap = 'hostK8sDiskCap',
hostK8sMemoryCap = 'hostK8sMemoryCap',
hostK8sPodCap = 'hostK8sPodCap',
hostLoad = 'hostLoad',
hostMemoryUsage = 'hostMemoryUsage',
hostNetworkTraffic = 'hostNetworkTraffic',
podOverview = 'podOverview',
podCpuUsage = 'podCpuUsage',
podMemoryUsage = 'podMemoryUsage',
podLogUsage = 'podLogUsage',
podNetworkTraffic = 'podNetworkTraffic',
containerOverview = 'containerOverview',
containerCpuKernel = 'containerCpuKernel',
containerCpuUsage = 'containerCpuUsage',
containerDiskIOOps = 'containerDiskIOOps',
containerDiskIOBytes = 'containerDiskIOBytes',
containerMemory = 'containerMemory',
containerNetworkTraffic = 'containerNetworkTraffic',
nginxHits = 'nginxHits',
nginxRequestRate = 'nginxRequestRate',
nginxActiveConnections = 'nginxActiveConnections',
nginxRequestsPerConnection = 'nginxRequestsPerConnection',
}
export enum InfraOperator {
gt = 'gt',
gte = 'gte',
lt = 'lt',
lte = 'lte',
eq = 'eq',
}
// ====================================================
// Unions
// ====================================================
/** A segment of the log entry message */
export type InfraLogMessageSegment = InfraLogMessageFieldSegment | InfraLogMessageConstantSegment;
// ====================================================
// END: Typescript template
// ====================================================
// ====================================================
// Documents
// ====================================================
export namespace MetadataQuery {
export type Variables = {
sourceId: string;
nodeId: string;
nodeType: InfraNodeType;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
metadataByNode: (MetadataByNode | null)[];
};
export type MetadataByNode = {
__typename?: 'InfraNodeMetadata';
name: string;
source: string;
};
}
export namespace MetricsQuery {
export type Variables = {
sourceId: string;
timerange: InfraTimerangeInput;
metrics: InfraMetric[];
nodeId: string;
nodeType: InfraNodeType;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
metrics: Metrics[];
};
export type Metrics = {
__typename?: 'InfraMetricData';
id?: InfraMetric | null;
series: Series[];
};
export type Series = {
__typename?: 'InfraDataSeries';
id: string;
data: Data[];
};
export type Data = {
__typename?: 'InfraDataPoint';
timestamp: number;
value?: number | null;
};
}
export namespace WaffleNodesQuery {
export type Variables = {
sourceId: string;
timerange: InfraTimerangeInput;
filterQuery?: string | null;
metric: InfraMetricInput;
path: InfraPathInput[];
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
map?: Map | null;
};
export type Map = {
__typename?: 'InfraResponse';
nodes: Nodes[];
};
export type Nodes = {
__typename?: 'InfraNode';
path: Path[];
metric: Metric;
};
export type Path = {
__typename?: 'InfraNodePath';
value: string;
};
export type Metric = {
__typename?: 'InfraNodeMetric';
name: InfraMetricType;
value: number;
};
}
export namespace SourceQuery {
export type Variables = {
sourceId?: string | null;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
configuration: Configuration;
status: Status;
};
export type Configuration = {
__typename?: 'InfraSourceConfiguration';
metricAlias: string;
logAlias: string;
fields: Fields;
};
export type Fields = {
__typename?: 'InfraSourceFields';
container: string;
host: string;
pod: string;
};
export type Status = {
__typename?: 'InfraSourceStatus';
indexFields: IndexFields[];
logIndicesExist: boolean;
metricIndicesExist: boolean;
};
export type IndexFields = {
__typename?: 'InfraIndexField';
name: string;
type: string;
searchable: boolean;
aggregatable: boolean;
};
}
export namespace LogEntries {
export type Variables = {
sourceId?: string | null;
timeKey: InfraTimeKeyInput;
countBefore?: number | null;
countAfter?: number | null;
filterQuery?: string | null;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
logEntriesAround: LogEntriesAround;
};
export type LogEntriesAround = {
__typename?: 'InfraLogEntryInterval';
start?: Start | null;
end?: End | null;
hasMoreBefore: boolean;
hasMoreAfter: boolean;
entries: Entries[];
};
export type Start = InfraTimeKeyFields.Fragment;
export type End = InfraTimeKeyFields.Fragment;
export type Entries = {
__typename?: 'InfraLogEntry';
gid: string;
key: Key;
message: Message[];
};
export type Key = {
__typename?: 'InfraTimeKey';
time: number;
tiebreaker: number;
};
export type Message =
| InfraLogMessageFieldSegmentInlineFragment
| InfraLogMessageConstantSegmentInlineFragment;
export type InfraLogMessageFieldSegmentInlineFragment = {
__typename?: 'InfraLogMessageFieldSegment';
field: string;
value: string;
};
export type InfraLogMessageConstantSegmentInlineFragment = {
__typename?: 'InfraLogMessageConstantSegment';
constant: string;
};
}
export namespace LogSummary {
export type Variables = {
sourceId?: string | null;
start: number;
end: number;
bucketSize: number;
filterQuery?: string | null;
};
export type Query = {
__typename?: 'Query';
source: Source;
};
export type Source = {
__typename?: 'InfraSource';
id: string;
logSummaryBetween: LogSummaryBetween;
};
export type LogSummaryBetween = {
__typename?: 'InfraLogSummaryInterval';
start?: number | null;
end?: number | null;
buckets: Buckets[];
};
export type Buckets = {
__typename?: 'InfraLogSummaryBucket';
start: number;
end: number;
entriesCount: number;
};
}
export namespace InfraTimeKeyFields {
export type Fragment = {
__typename?: 'InfraTimeKey';
time: number;
tiebreaker: number;
};
}

2
x-pack/plugins/infra/public/lib/compose/kibana_compose.ts
View file

@ -15,7 +15,7 @@ import { timezoneProvider } from 'ui/vis/lib/timezone';
import { InfraKibanaObservableApiAdapter } from '../adapters/observable_api/kibana_observable_api';
import introspectionQueryResultData from '../../../common/graphql/introspection.json';
import introspectionQueryResultData from '../../graphql/introspection.json';
import { InfraKibanaFrameworkAdapter } from '../adapters/framework/kibana_framework_adapter';
import { InfraFrontendLibs } from '../lib';

2
x-pack/plugins/infra/public/lib/lib.ts
View file

@ -17,7 +17,7 @@ import {
InfraPathInput,
InfraTimerangeInput,
SourceQuery,
} from '../../common/graphql/types';
} from '../graphql/types';
export interface InfraFrontendLibs {
framework: InfraFrameworkAdapter;

5
x-pack/plugins/infra/public/pages/home/toolbar.tsx
View file

@ -11,17 +11,16 @@ import React from 'react';
import { AutocompleteField } from '../../components/autocomplete_field';
import { Toolbar } from '../../components/eui/toolbar';
import { WaffleTimeControls } from '../../components/waffle/waffle_time_controls';
import { InfraNodeType } from '../../../common/graphql/types';
import { WaffleGroupByControls } from '../../components/waffle/waffle_group_by_controls';
import { WaffleMetricControls } from '../../components/waffle/waffle_metric_controls';
import { WaffleNodeTypeSwitcher } from '../../components/waffle/waffle_node_type_switcher';
import { WaffleTimeControls } from '../../components/waffle/waffle_time_controls';
import { WithWaffleFilter } from '../../containers/waffle/with_waffle_filters';
import { WithWaffleOptions } from '../../containers/waffle/with_waffle_options';
import { WithWaffleTime } from '../../containers/waffle/with_waffle_time';
import { WithKueryAutocompletion } from '../../containers/with_kuery_autocompletion';
import { WithSource } from '../../containers/with_source';
import { InfraNodeType } from '../../graphql/types';
const getTitle = (nodeType: string) => {
const TITLES = {

3
x-pack/plugins/infra/public/pages/link_to/redirect_to_node_detail.tsx
View file

@ -6,8 +6,9 @@
import React from 'react';
import { Redirect, RouteComponentProps } from 'react-router-dom';
import { InfraNodeType } from 'x-pack/plugins/infra/common/graphql/types';
import { replaceMetricTimeInQueryString } from '../../containers/metrics/with_metrics_time';
import { InfraNodeType } from '../../graphql/types';
import { getFromFromLocation, getToFromLocation } from './query_params';
type RedirectToNodeDetailProps = RouteComponentProps<{

2
x-pack/plugins/infra/public/pages/link_to/redirect_to_node_logs.tsx
View file

@ -9,11 +9,11 @@ import compose from 'lodash/fp/compose';
import React from 'react';
import { Redirect, RouteComponentProps } from 'react-router-dom';
import { InfraNodeType } from 'x-pack/plugins/infra/common/graphql/types';
import { LoadingPage } from '../../components/loading_page';
import { replaceLogFilterInQueryString } from '../../containers/logs/with_log_filter';
import { replaceLogPositionInQueryString } from '../../containers/logs/with_log_position';
import { WithSource } from '../../containers/with_source';
import { InfraNodeType } from '../../graphql/types';
import { getTimeFromLocation } from './query_params';
type RedirectToNodeLogsType = RouteComponentProps<{

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

@ -3,7 +3,6 @@
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
import React from 'react';
import {
EuiHideFor,
@ -15,8 +14,9 @@ import {
EuiTitle,
} from '@elastic/eui';
import { InjectedIntl, injectI18n } from '@kbn/i18n/react';
import React from 'react';
import styled, { withTheme } from 'styled-components';
import { InfraNodeType, InfraTimerangeInput } from '../../../common/graphql/types';
import { AutoSizer } from '../../components/auto_sizer';
import { InfrastructureBetaBadgeHeaderSection } from '../../components/beta_badge_header_section';
import { Header } from '../../components/header';
@ -31,6 +31,7 @@ import {
WithMetricsTimeUrlState,
} from '../../containers/metrics/with_metrics_time';
import { WithOptions } from '../../containers/with_options';
import { InfraNodeType, InfraTimerangeInput } from '../../graphql/types';
import { Error, ErrorPageBody } from '../error';
import { layoutCreators } from './layouts';
import { InfraMetricLayoutSection } from './layouts/types';

2
x-pack/plugins/infra/public/pages/metrics/layouts/container.ts
View file

@ -5,7 +5,7 @@
*/
import { i18n } from '@kbn/i18n';
import { InfraMetric } from '../../../../common/graphql/types';
import { InfraMetric } from '../../../graphql/types';
import { InfraFormatterType } from '../../../lib/lib';
import { nginxLayoutCreator } from './nginx';
import {

2
x-pack/plugins/infra/public/pages/metrics/layouts/host.ts
View file

@ -5,7 +5,7 @@
*/
import { i18n } from '@kbn/i18n';
import { InfraMetric } from '../../../../common/graphql/types';
import { InfraMetric } from '../../../graphql/types';
import { InfraFormatterType } from '../../../lib/lib';
import { nginxLayoutCreator } from './nginx';
import {

2
x-pack/plugins/infra/public/pages/metrics/layouts/nginx.ts
View file

@ -5,7 +5,7 @@
*/
import { i18n } from '@kbn/i18n';
import { InfraMetric } from '../../../../common/graphql/types';
import { InfraMetric } from '../../../graphql/types';
import { InfraFormatterType } from '../../../lib/lib';
import {
InfraMetricLayoutCreator,

2
x-pack/plugins/infra/public/pages/metrics/layouts/pod.ts
View file

@ -5,7 +5,7 @@
*/
import { i18n } from '@kbn/i18n';
import { InfraMetric } from '../../../../common/graphql/types';
import { InfraMetric } from '../../../graphql/types';
import { InfraFormatterType } from '../../../lib/lib';
import { nginxLayoutCreator } from './nginx';
import {

2
x-pack/plugins/infra/public/pages/metrics/layouts/types.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraMetric } from '../../../../common/graphql/types';
import { InfraMetric } from '../../../graphql/types';
import { InfraFormatterType } from '../../../lib/lib';
export enum InfraMetricLayoutVisualizationType {

4
x-pack/plugins/infra/public/store/local/waffle_options/actions.ts
View file

@ -5,8 +5,8 @@
*/
import actionCreatorFactory from 'typescript-fsa';
import { InfraMetricInput, InfraPathInput } from '../../../../common/graphql/types';
import { InfraNodeType } from '../../../../server/lib/adapters/nodes';
import { InfraMetricInput, InfraNodeType, InfraPathInput } from '../../../graphql/types';
const actionCreator = actionCreatorFactory('x-pack/infra/local/waffle_options');

4
x-pack/plugins/infra/public/store/local/waffle_options/reducer.ts
View file

@ -10,9 +10,9 @@ import { reducerWithInitialState } from 'typescript-fsa-reducers';
import {
InfraMetricInput,
InfraMetricType,
InfraNodeType,
InfraPathInput,
} from '../../../../common/graphql/types';
import { InfraNodeType } from '../../../../server/lib/adapters/nodes';
} from '../../../graphql/types';
import { changeGroupBy, changeMetric, changeNodeType } from './actions';
export interface WaffleOptionsState {

2
x-pack/plugins/infra/public/store/remote/log_entries/operations/load.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { LogEntries as LogEntriesQuery } from '../../../../../common/graphql/types';
import { LogEntries as LogEntriesQuery } from '../../../../graphql/types';
import {
createGraphqlOperationActionCreators,
createGraphqlOperationReducer,

2
x-pack/plugins/infra/public/store/remote/log_entries/operations/load_more.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { LogEntries as LogEntriesQuery } from '../../../../../common/graphql/types';
import { LogEntries as LogEntriesQuery } from '../../../../graphql/types';
import {
getLogEntryIndexAfterTime,
getLogEntryIndexBeforeTime,

2
x-pack/plugins/infra/public/store/remote/log_entries/state.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { LogEntries as LogEntriesQuery } from '../../../../common/graphql/types';
import { LogEntries as LogEntriesQuery } from '../../../graphql/types';
import {
createGraphqlInitialState,
GraphqlState,

2
x-pack/plugins/infra/public/store/remote/log_summary/operations/load.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { LogSummary as LogSummaryQuery } from '../../../../../common/graphql/types';
import { LogSummary as LogSummaryQuery } from '../../../../graphql/types';
import {
createGraphqlOperationActionCreators,
createGraphqlOperationReducer,

2
x-pack/plugins/infra/public/store/remote/log_summary/state.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { LogSummary as LogSummaryQuery } from '../../../../common/graphql/types';
import { LogSummary as LogSummaryQuery } from '../../../graphql/types';
import {
createGraphqlInitialState,
GraphqlState,

2
x-pack/plugins/infra/public/utils/log_entry/log_entry.ts
View file

@ -6,8 +6,8 @@
import { bisector } from 'd3-array';
import { LogEntries as LogEntriesQuery } from '../../../common/graphql/types';
import { compareToTimeKey, getIndexAtTimeKey, TimeKey } from '../../../common/time';
import { LogEntries as LogEntriesQuery } from '../../graphql/types';
export type LogEntry = LogEntriesQuery.Entries;

25
x-pack/plugins/infra/scripts/generate_types_from_graphql.js
View file

@ -13,16 +13,18 @@ const GRAPHQL_GLOBS = [
join('public', 'store', '**', '*.gql_query.ts{,x}'),
join('common', 'graphql', '**', '*.gql_query.ts{,x}'),
];
const CONFIG_PATH = resolve(__dirname, 'gql_gen.json');
const OUTPUT_INTROSPECTION_PATH = resolve('common', 'graphql', 'introspection.json');
const OUTPUT_TYPES_PATH = resolve('common', 'graphql', 'types.ts');
const CLIENT_CONFIG_PATH = resolve(__dirname, 'gql_gen_client.json');
const SERVER_CONFIG_PATH = resolve(__dirname, 'gql_gen_server.json');
const OUTPUT_INTROSPECTION_PATH = resolve('public', 'graphql', 'introspection.json');
const OUTPUT_CLIENT_TYPES_PATH = resolve('public', 'graphql', 'types.ts');
const OUTPUT_SERVER_TYPES_PATH = resolve('server', 'graphql', 'types.ts');
const SCHEMA_PATH = resolve(__dirname, 'combined_schema.ts');
async function main() {
await generate(
{
args: GRAPHQL_GLOBS,
config: CONFIG_PATH,
config: SERVER_CONFIG_PATH,
out: OUTPUT_INTROSPECTION_PATH,
overwrite: true,
require: ['ts-node/register'],
@ -34,14 +36,25 @@ async function main() {
await generate(
{
args: GRAPHQL_GLOBS,
config: CONFIG_PATH,
out: OUTPUT_TYPES_PATH,
config: CLIENT_CONFIG_PATH,
out: OUTPUT_CLIENT_TYPES_PATH,
overwrite: true,
schema: SCHEMA_PATH,
template: 'graphql-codegen-typescript-template',
},
true
);
await generate(
{
args: [],
config: SERVER_CONFIG_PATH,
out: OUTPUT_SERVER_TYPES_PATH,
overwrite: true,
schema: SCHEMA_PATH,
template: 'graphql-codegen-typescript-resolvers-template',
},
true
);
}
if (require.main === module) {

0
x-pack/plugins/infra/scripts/gql_gen.json → x-pack/plugins/infra/scripts/gql_gen_client.json
View file

14
x-pack/plugins/infra/scripts/gql_gen_server.json Normal file
View file

@ -0,0 +1,14 @@
{
"flattenTypes": true,
"generatorConfig": {
"contextType": "InfraContext",
"prepend": ["import { InfraContext } from '../lib/infra_types';"]
},
"primitives": {
"String": "string",
"Int": "number",
"Float": "number",
"Boolean": "boolean",
"ID": "string"
}
}

26
x-pack/plugins/infra/server/graphql/log_entries/resolvers.ts
View file

@ -9,30 +9,26 @@ import {
InfraLogMessageFieldSegment,
InfraLogMessageSegment,
InfraSourceResolvers,
} from '../../../common/graphql/types';
import { InfraResolvedResult, InfraResolverOf } from '../../lib/adapters/framework';
} from '../../graphql/types';
import { InfraLogEntriesDomain } from '../../lib/domains/log_entries_domain';
import { InfraContext } from '../../lib/infra_types';
import { UsageCollector } from '../../usage/usage_collector';
import { parseFilterQuery } from '../../utils/serialized_query';
import { ChildResolverOf, InfraResolverOf } from '../../utils/typed_resolvers';
import { QuerySourceResolver } from '../sources/resolvers';
export type InfraSourceLogEntriesAroundResolver = InfraResolverOf<
InfraSourceResolvers.LogEntriesAroundResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceLogEntriesAroundResolver = ChildResolverOf<
InfraResolverOf<InfraSourceResolvers.LogEntriesAroundResolver>,
QuerySourceResolver
>;
export type InfraSourceLogEntriesBetweenResolver = InfraResolverOf<
InfraSourceResolvers.LogEntriesBetweenResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceLogEntriesBetweenResolver = ChildResolverOf<
InfraResolverOf<InfraSourceResolvers.LogEntriesBetweenResolver>,
QuerySourceResolver
>;
export type InfraSourceLogSummaryBetweenResolver = InfraResolverOf<
InfraSourceResolvers.LogSummaryBetweenResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceLogSummaryBetweenResolver = ChildResolverOf<
InfraResolverOf<InfraSourceResolvers.LogSummaryBetweenResolver>,
QuerySourceResolver
>;
export const createLogEntriesResolvers = (libs: {

12
x-pack/plugins/infra/server/graphql/metadata/resolvers.ts
View file

@ -4,16 +4,14 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraSourceResolvers } from '../../../common/graphql/types';
import { InfraResolvedResult, InfraResolverOf } from '../../lib/adapters/framework';
import { InfraSourceResolvers } from '../../graphql/types';
import { InfraMetadataDomain } from '../../lib/domains/metadata_domain';
import { InfraContext } from '../../lib/infra_types';
import { ChildResolverOf, InfraResolverOf } from '../../utils/typed_resolvers';
import { QuerySourceResolver } from '../sources/resolvers';
type InfraSourceMetadataByNodeResolver = InfraResolverOf<
InfraSourceResolvers.MetadataByNodeResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
type InfraSourceMetadataByNodeResolver = ChildResolverOf<
InfraResolverOf<InfraSourceResolvers.MetadataByNodeResolver>,
QuerySourceResolver
>;
export const createMetadataResolvers = (libs: {

12
x-pack/plugins/infra/server/graphql/metrics/resolvers.ts
View file

@ -4,17 +4,15 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraSourceResolvers } from '../../../common/graphql/types';
import { InfraResolvedResult, InfraResolverOf } from '../../lib/adapters/framework';
import { InfraSourceResolvers } from '../../graphql/types';
import { InfraMetricsDomain } from '../../lib/domains/metrics_domain';
import { InfraContext } from '../../lib/infra_types';
import { UsageCollector } from '../../usage/usage_collector';
import { ChildResolverOf, InfraResolverOf } from '../../utils/typed_resolvers';
import { QuerySourceResolver } from '../sources/resolvers';
type InfraSourceMetricsResolver = InfraResolverOf<
InfraSourceResolvers.MetricsResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
type InfraSourceMetricsResolver = ChildResolverOf<
InfraResolverOf<InfraSourceResolvers.MetricsResolver>,
QuerySourceResolver
>;
interface ResolverDeps {

34
x-pack/plugins/infra/server/graphql/nodes/resolvers.ts
View file

@ -4,35 +4,29 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraResponseResolvers, InfraSourceResolvers } from '../../../common/graphql/types';
import {
InfraResolvedResult,
InfraResolverOf,
InfraResolverWithoutFields,
} from '../../lib/adapters/framework';
import { InfraResponseResolvers, InfraSourceResolvers } from '../../graphql/types';
import { InfraNodeRequestOptions } from '../../lib/adapters/nodes';
import { extractGroupByAndNodeFromPath } from '../../lib/adapters/nodes/extract_group_by_and_node_from_path';
import { InfraNodesDomain } from '../../lib/domains/nodes_domain';
import { InfraContext } from '../../lib/infra_types';
import { UsageCollector } from '../../usage/usage_collector';
import { parseFilterQuery } from '../../utils/serialized_query';
import { ChildResolverOf, InfraResolverOf, ResultOf } from '../../utils/typed_resolvers';
import { QuerySourceResolver } from '../sources/resolvers';
type InfraSourceMapResolver = InfraResolverWithoutFields<
InfraSourceResolvers.MapResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext,
'nodes'
type InfraSourceMapResolver = ChildResolverOf<
InfraResolverOf<
InfraSourceResolvers.MapResolver<
{
source: ResultOf<QuerySourceResolver>;
} & InfraSourceResolvers.MapArgs
>
>,
QuerySourceResolver
>;
interface QueryMapResponse extends InfraSourceResolvers.MapArgs {
source: InfraResolvedResult<QuerySourceResolver>;
}
type InfraNodesResolver = InfraResolverOf<
InfraResponseResolvers.NodesResolver,
QueryMapResponse,
InfraContext
type InfraNodesResolver = ChildResolverOf<
InfraResolverOf<InfraResponseResolvers.NodesResolver>,
InfraSourceMapResolver
>;
interface NodesResolversDeps {

54
x-pack/plugins/infra/server/graphql/source_status/resolvers.ts
View file

@ -4,53 +4,45 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraIndexType, InfraSourceStatusResolvers } from '../../../common/graphql/types';
import { InfraResolvedResult, InfraResolverOf } from '../../lib/adapters/framework';
import { InfraIndexType, InfraSourceStatusResolvers } from '../../graphql/types';
import { InfraFieldsDomain } from '../../lib/domains/fields_domain';
import { InfraContext } from '../../lib/infra_types';
import { InfraSourceStatus } from '../../lib/source_status';
import { ChildResolverOf, InfraResolverOf } from '../../utils/typed_resolvers';
import { QuerySourceResolver } from '../sources/resolvers';
export type InfraSourceStatusMetricAliasExistsResolver = InfraResolverOf<
InfraSourceStatusResolvers.MetricAliasExistsResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceStatusMetricAliasExistsResolver = ChildResolverOf<
InfraResolverOf<InfraSourceStatusResolvers.MetricAliasExistsResolver>,
QuerySourceResolver
>;
export type InfraSourceStatusMetricIndicesExistResolver = InfraResolverOf<
InfraSourceStatusResolvers.MetricIndicesExistResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceStatusMetricIndicesExistResolver = ChildResolverOf<
InfraResolverOf<InfraSourceStatusResolvers.MetricIndicesExistResolver>,
QuerySourceResolver
>;
export type InfraSourceStatusMetricIndicesResolver = InfraResolverOf<
InfraSourceStatusResolvers.MetricIndicesResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceStatusMetricIndicesResolver = ChildResolverOf<
InfraResolverOf<InfraSourceStatusResolvers.MetricIndicesResolver>,
QuerySourceResolver
>;
export type InfraSourceStatusLogAliasExistsResolver = InfraResolverOf<
InfraSourceStatusResolvers.LogAliasExistsResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceStatusLogAliasExistsResolver = ChildResolverOf<
InfraResolverOf<InfraSourceStatusResolvers.LogAliasExistsResolver>,
QuerySourceResolver
>;
export type InfraSourceStatusLogIndicesExistResolver = InfraResolverOf<
InfraSourceStatusResolvers.LogIndicesExistResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceStatusLogIndicesExistResolver = ChildResolverOf<
InfraResolverOf<InfraSourceStatusResolvers.LogIndicesExistResolver>,
QuerySourceResolver
>;
export type InfraSourceStatusLogIndicesResolver = InfraResolverOf<
InfraSourceStatusResolvers.LogIndicesResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceStatusLogIndicesResolver = ChildResolverOf<
InfraResolverOf<InfraSourceStatusResolvers.LogIndicesResolver>,
QuerySourceResolver
>;
export type InfraSourceStatusIndexFieldsResolver = InfraResolverOf<
InfraSourceStatusResolvers.IndexFieldsResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext
export type InfraSourceStatusIndexFieldsResolver = ChildResolverOf<
InfraResolverOf<InfraSourceStatusResolvers.IndexFieldsResolver>,
QuerySourceResolver
>;
export const createSourceStatusResolvers = (libs: {

22
x-pack/plugins/infra/server/graphql/sources/resolvers.ts
View file

@ -4,31 +4,29 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraSourceResolvers, QueryResolvers } from '../../../common/graphql/types';
import { InfraResolvedResult, InfraResolverWithFields } from '../../lib/adapters/framework';
import { InfraContext } from '../../lib/infra_types';
import { InfraSourceResolvers, QueryResolvers } from '../../graphql/types';
import { InfraSourceStatus } from '../../lib/source_status';
import { InfraSources } from '../../lib/sources';
import {
ChildResolverOf,
InfraResolverOf,
InfraResolverWithFields,
ResultOf,
} from '../../utils/typed_resolvers';
export type QuerySourceResolver = InfraResolverWithFields<
QueryResolvers.SourceResolver,
null,
InfraContext,
'id' | 'configuration'
>;
export type QueryAllSourcesResolver = InfraResolverWithFields<
QueryResolvers.AllSourcesResolver,
null,
InfraContext,
'id' | 'configuration'
>;
export type InfraSourceStatusResolver = InfraResolverWithFields<
InfraSourceResolvers.StatusResolver,
InfraResolvedResult<QuerySourceResolver>,
InfraContext,
never
export type InfraSourceStatusResolver = ChildResolverOf<
InfraResolverOf<InfraSourceResolvers.StatusResolver<ResultOf<QuerySourceResolver>>>,
QuerySourceResolver
>;
interface SourcesResolversDeps {

1098
x-pack/plugins/infra/server/graphql/types.ts Normal file
View file

File diff suppressed because it is too large Load diff

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

@ -9,7 +9,6 @@ import { GraphQLSchema } from 'graphql';
import { Lifecycle, ResponseToolkit, RouteOptions } from 'hapi';
import { InfraMetricModel } from '../metrics/adapter_types';
export * from '../../../../common/graphql/typed_resolvers';
import { JsonObject } from '../../../../common/typed_json';
export const internalInfraFrameworkRequest = Symbol('internalInfraFrameworkRequest');

2
x-pack/plugins/infra/server/lib/adapters/metrics/adapter_types.ts
View file

@ -9,7 +9,7 @@ import {
InfraMetricData,
InfraNodeType,
InfraTimerangeInput,
} from '../../../../common/graphql/types';
} from '../../../graphql/types';
import { InfraSourceConfiguration } from '../../sources';
import { InfraFrameworkRequest } from '../framework';

3
x-pack/plugins/infra/server/lib/adapters/metrics/kibana_metrics_adapter.ts
View file

@ -6,7 +6,8 @@
import { i18n } from '@kbn/i18n';
import { flatten } from 'lodash';
import { InfraMetric, InfraMetricData, InfraNodeType } from '../../../../common/graphql/types';
import { InfraMetric, InfraMetricData, InfraNodeType } from '../../../graphql/types';
import { InfraBackendFrameworkAdapter, InfraFrameworkRequest } from '../framework';
import { InfraMetricsAdapter, InfraMetricsRequestOptions } from './adapter_types';
import { checkValidNode } from './lib/check_valid_node';

2
x-pack/plugins/infra/server/lib/adapters/metrics/models/index.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraMetric } from '../../../../../common/graphql/types';
import { InfraMetric } from '../../../../graphql/types';
import { InfraMetricModelCreator } from '../adapter_types';
import { hostCpuUsage } from './host/host_cpu_usage';

4
x-pack/plugins/infra/server/lib/adapters/nodes/adapter_types.ts
View file

@ -4,6 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { JsonObject } from '../../../../common/typed_json';
import {
InfraMetricInput,
InfraNode,
@ -11,8 +12,7 @@ import {
InfraPathInput,
InfraPathType,
InfraTimerangeInput,
} from '../../../../common/graphql/types';
import { JsonObject } from '../../../../common/typed_json';
} from '../../../graphql/types';
import { InfraSourceConfiguration } from '../../sources';
import { InfraFrameworkRequest } from '../framework';

2
x-pack/plugins/infra/server/lib/adapters/nodes/elasticsearch_nodes_adapter.ts
View file

@ -12,7 +12,7 @@ import {
InfraNodesAggregations,
} from './adapter_types';
import { InfraNode } from '../../../../common/graphql/types';
import { InfraNode } from '../../../graphql/types';
import { calculateCardinalityOfNodeField } from './lib/calculate_cardinality';
import { createPartitionBodies } from './lib/create_partition_bodies';
import { processNodes } from './lib/process_nodes';

2
x-pack/plugins/infra/server/lib/adapters/nodes/extract_group_by_and_node_from_path.ts
View file

@ -3,7 +3,7 @@
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraPathInput, InfraPathType } from '../../../../common/graphql/types';
import { InfraPathInput, InfraPathType } from '../../../graphql/types';
import { InfraNodeType } from './adapter_types';
const getNodeType = (type: InfraPathType): InfraNodeType => {

2
x-pack/plugins/infra/server/lib/adapters/nodes/lib/convert_nodes_response_to_groups.ts
View file

@ -3,7 +3,7 @@
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraNode } from '../../../../../common/graphql/types';
import { InfraNode } from '../../../../graphql/types';
import { InfraBucket, InfraNodeRequestOptions } from '../adapter_types';
import { extractGroupPaths } from './extract_group_paths';

2
x-pack/plugins/infra/server/lib/adapters/nodes/lib/create_base_path.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraPathInput } from '../../../../../common/graphql/types';
import { InfraPathInput } from '../../../../graphql/types';
export const createBasePath = (groupBy: InfraPathInput[]) => {
const basePath = ['aggs', 'waffle', 'aggs', 'nodes', 'aggs'];
return groupBy.reduce((acc, group, index) => {

3
x-pack/plugins/infra/server/lib/adapters/nodes/lib/create_node_item.ts
View file

@ -7,7 +7,8 @@
import { last } from 'lodash';
import { isNumber } from 'lodash';
import moment from 'moment';
import { InfraNode, InfraNodeMetric } from '../../../../../common/graphql/types';
import { InfraNode, InfraNodeMetric } from '../../../../graphql/types';
import { InfraBucket, InfraNodeRequestOptions } from '../adapter_types';
import { getBucketSizeInSeconds } from './get_bucket_size_in_seconds';

2
x-pack/plugins/infra/server/lib/adapters/nodes/lib/create_partition_bodies.ts
View file

@ -6,7 +6,7 @@
import { times } from 'lodash';
import { InfraMetricType } from '../../../../../common/graphql/types';
import { InfraMetricType } from '../../../../graphql/types';
import {
InfraESMSearchBody,
InfraNodeRequestOptions,

2
x-pack/plugins/infra/server/lib/adapters/nodes/lib/create_query.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraPathFilterInput, InfraPathInput } from '../../../../../common/graphql/types';
import { InfraPathFilterInput, InfraPathInput } from '../../../../graphql/types';
import {
InfraESBoolQuery,

2
x-pack/plugins/infra/server/lib/adapters/nodes/lib/extract_group_paths.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraNode, InfraPathInput } from '../../../../../common/graphql/types';
import { InfraNode, InfraPathInput } from '../../../../graphql/types';
import { InfraBucket, InfraNodeRequestOptions } from '../adapter_types';
import { createNodeItem } from './create_node_item';

2
x-pack/plugins/infra/server/lib/adapters/nodes/lib/process_nodes.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraNode } from '../../../../../common/graphql/types';
import { InfraNode } from '../../../../graphql/types';
import { InfraBucket, InfraNodeRequestOptions } from '../adapter_types';
import { convertNodesResponseToGroups } from './convert_nodes_response_to_groups';
import { createNodeItem } from './create_node_item';

2
x-pack/plugins/infra/server/lib/adapters/nodes/lib/type_guards.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraPathInput, InfraPathType } from '../../../../../common/graphql/types';
import { InfraPathInput, InfraPathType } from '../../../../graphql/types';
import { InfraGroupByFilters, InfraGroupByTerms } from '../adapter_types';
export function isGroupByFilters(value: InfraPathInput): value is InfraGroupByFilters {

2
x-pack/plugins/infra/server/lib/adapters/nodes/metric_aggregation_creators/index.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraMetricType } from '../../../../../common/graphql/types';
import { InfraMetricType } from '../../../../graphql/types';
import { count } from './count';
import { cpu } from './cpu';
import { load } from './load';

2
x-pack/plugins/infra/server/lib/adapters/nodes/processors/common/group_by_processor.ts
View file

@ -6,7 +6,7 @@
import { cloneDeep, set } from 'lodash';
import { InfraPathFilterInput, InfraPathInput } from '../../../../../../common/graphql/types';
import { InfraPathFilterInput, InfraPathInput } from '../../../../../graphql/types';
import {
InfraESQueryStringQuery,
InfraESSearchBody,

2
x-pack/plugins/infra/server/lib/domains/fields_domain.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraIndexField, InfraIndexType } from '../../../common/graphql/types';
import { InfraIndexField, InfraIndexType } from '../../graphql/types';
import { FieldsAdapter } from '../adapters/fields';
import { InfraFrameworkRequest } from '../adapters/framework';
import { InfraSources } from '../sources';

6
x-pack/plugins/infra/server/lib/domains/log_entries_domain/log_entries_domain.ts
View file

@ -4,13 +4,13 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { TimeKey } from '../../../../common/time';
import { JsonObject } from '../../../../common/typed_json';
import {
InfraLogEntry,
InfraLogMessageSegment,
InfraLogSummaryBucket,
} from '../../../../common/graphql/types';
import { TimeKey } from '../../../../common/time';
import { JsonObject } from '../../../../common/typed_json';
} from '../../../graphql/types';
import { InfraDateRangeAggregationBucket, InfraFrameworkRequest } from '../../adapters/framework';
import { InfraSourceConfiguration, InfraSources } from '../../sources';
import { builtinRules } from './builtin_rules';

2
x-pack/plugins/infra/server/lib/domains/log_entries_domain/message.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraLogMessageSegment } from '../../../../common/graphql/types';
import { InfraLogMessageSegment } from '../../../graphql/types';
export function compileFormattingRules(rules: LogMessageFormattingRule[]) {
const compiledRules = rules.map(compileRule);

2
x-pack/plugins/infra/server/lib/domains/metrics_domain.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraMetricData } from '../../../common/graphql/types';
import { InfraMetricData } from '../../graphql/types';
import { InfraFrameworkRequest } from '../adapters/framework/adapter_types';
import { InfraMetricsAdapter, InfraMetricsRequestOptions } from '../adapters/metrics/adapter_types';

2
x-pack/plugins/infra/server/lib/domains/nodes_domain.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraNode } from '../../../common/graphql/types';
import { InfraNode } from '../../graphql/types';
import { InfraFrameworkRequest } from '../adapters/framework';
import { InfraNodeRequestOptions, InfraNodesAdapter } from '../adapters/nodes';

2
x-pack/plugins/infra/server/usage/usage_collector.ts
View file

@ -4,7 +4,7 @@
* you may not use this file except in compliance with the Elastic License.
*/
import { InfraNodeType } from '../../common/graphql/types';
import { InfraNodeType } from '../graphql/types';
import { KbnServer } from '../kibana.index';
const KIBANA_REPORTING_TYPE = 'infraops';

97
x-pack/plugins/infra/server/utils/typed_resolvers.ts Normal file
View file

@ -0,0 +1,97 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
import { Resolver } from '../graphql/types';
type ResolverResult<R> = R | Promise<R>;
type InfraResolverResult<R> =
| Promise<R>
| Promise<{ [P in keyof R]: () => Promise<R[P]> }>
| { [P in keyof R]: () => Promise<R[P]> }
| { [P in keyof R]: () => R[P] }
| R;
export type ResultOf<Resolver_> = Resolver_ extends Resolver<InfraResolverResult<infer Result>>
? Result
: never;
export type SubsetResolverWithFields<R, IncludedFields extends string> = R extends Resolver<
Array<infer ResultInArray>,
infer ParentInArray,
infer ContextInArray,
infer ArgsInArray
>
? Resolver<
Array<Pick<ResultInArray, Extract<keyof ResultInArray, IncludedFields>>>,
ParentInArray,
ContextInArray,
ArgsInArray
>
: R extends Resolver<infer Result, infer Parent, infer Context, infer Args>
? Resolver<Pick<Result, Extract<keyof Result, IncludedFields>>, Parent, Context, Args>
: never;
export type SubsetResolverWithoutFields<R, ExcludedFields extends string> = R extends Resolver<
Array<infer ResultInArray>,
infer ParentInArray,
infer ContextInArray,
infer ArgsInArray
>
? Resolver<
Array<Pick<ResultInArray, Exclude<keyof ResultInArray, ExcludedFields>>>,
ParentInArray,
ContextInArray,
ArgsInArray
>
: R extends Resolver<infer Result, infer Parent, infer Context, infer Args>
? Resolver<Pick<Result, Exclude<keyof Result, ExcludedFields>>, Parent, Context, Args>
: never;
export type ResolverWithParent<Resolver_, Parent> = Resolver_ extends Resolver<
infer Result,
any,
infer Context,
infer Args
>
? Resolver<Result, Parent, Context, Args>
: never;
export type InfraResolver<Result = any, Parent = any, Context = any, Args = any> = Resolver<
InfraResolverResult<Result>,
Parent,
Context,
Args
>;
export type InfraResolverOf<Resolver_> = Resolver_ extends Resolver<
ResolverResult<infer ResultWithNeverParent>,
never,
infer ContextWithNeverParent,
infer ArgsWithNeverParent
>
? InfraResolver<ResultWithNeverParent, {}, ContextWithNeverParent, ArgsWithNeverParent>
: Resolver_ extends Resolver<
ResolverResult<infer Result>,
infer Parent,
infer Context,
infer Args
>
? InfraResolver<Result, Parent, Context, Args>
: never;
export type InfraResolverWithFields<Resolver_, IncludedFields extends string> = InfraResolverOf<
SubsetResolverWithFields<Resolver_, IncludedFields>
>;
export type InfraResolverWithoutFields<Resolver_, ExcludedFields extends string> = InfraResolverOf<
SubsetResolverWithoutFields<Resolver_, ExcludedFields>
>;
export type ChildResolverOf<Resolver_, ParentResolver> = ResolverWithParent<
Resolver_,
ResultOf<ParentResolver>
>;

2
x-pack/test/api_integration/apis/infra/log_entries.ts
View file

@ -8,7 +8,7 @@ import { ascending, pairs } from 'd3-array';
import expect from 'expect.js';
import gql from 'graphql-tag';
import { InfraTimeKey } from '../../../../plugins/infra/common/graphql/types';
import { InfraTimeKey } from '../../../../plugins/infra/public/graphql/types';
import { KbnTestProvider } from './types';
const KEY_WITHIN_DATA_RANGE = {

3
x-pack/test/api_integration/apis/infra/metadata.ts
View file

@ -5,8 +5,9 @@
*/
import expect from 'expect.js';
import { MetadataQuery } from '../../../../plugins/infra/common/graphql/types';
import { metadataQuery } from '../../../../plugins/infra/public/containers/metadata/metadata.gql_query';
import { MetadataQuery } from '../../../../plugins/infra/public/graphql/types';
import { KbnTestProvider } from './types';
const metadataTests: KbnTestProvider = ({ getService }) => {

3
x-pack/test/api_integration/apis/infra/metrics.ts
View file

@ -6,8 +6,9 @@
import expect from 'expect.js';
import { first, last } from 'lodash';
import { MetricsQuery } from '../../../../plugins/infra/common/graphql/types';
import { metricsQuery } from '../../../../plugins/infra/public/containers/metrics/metrics.gql_query';
import { MetricsQuery } from '../../../../plugins/infra/public/graphql/types';
import { KbnTestProvider } from './types';
const metricTests: KbnTestProvider = ({ getService }) => {

4
x-pack/test/api_integration/apis/infra/sources.ts
View file

@ -5,9 +5,9 @@
*/
import expect from 'expect.js';
import { SourceQuery } from '../../../../plugins/infra/common/graphql/types';
import { sourceQuery } from '../../../../plugins/infra/public/containers/with_source/query_source.gql_query';
import { sourceQuery } from '../../../../plugins/infra/public/containers/with_source/query_source.gql_query';
import { SourceQuery } from '../../../../plugins/infra/public/graphql/types';
import { KbnTestProvider } from './types';
const sourcesTests: KbnTestProvider = ({ getService }) => {

3
x-pack/test/api_integration/apis/infra/waffle.ts
View file

@ -6,8 +6,9 @@
import expect from 'expect.js';
import { first, last } from 'lodash';
import { WaffleNodesQuery } from '../../../../plugins/infra/common/graphql/types';
import { waffleNodesQuery } from '../../../../plugins/infra/public/containers/waffle/waffle_nodes.gql_query';
import { WaffleNodesQuery } from '../../../../plugins/infra/public/graphql/types';
import { KbnTestProvider } from './types';
const waffleTests: KbnTestProvider = ({ getService }) => {

2
x-pack/test/api_integration/services/infraops_graphql_client.js
View file

@ -10,7 +10,7 @@ import { InMemoryCache, IntrospectionFragmentMatcher } from 'apollo-cache-inmemo
import { ApolloClient } from 'apollo-client';
import { HttpLink } from 'apollo-link-http';
import introspectionQueryResultData from '../../../plugins/infra/common/graphql/introspection.json';
import introspectionQueryResultData from '../../../plugins/infra/public/graphql/introspection.json';
export function InfraOpsGraphQLProvider({ getService }) {
const config = getService('config');

9
yarn.lock
View file

@ -9756,7 +9756,14 @@ graphql-codegen-introspection-template@^0.13.0:
resolved "https://registry.yarnpkg.com/graphql-codegen-introspection-template/-/graphql-codegen-introspection-template-0.13.0.tgz#7bd4ae777f1a8d078a09974866fe27a0d928a040"
integrity sha512-qYzupnNEr6EI3r0sHhEl0wvlgTpuzWx4MkVCY5rgeSweLOLKlmrwCySMZ8lxzFR9D1Y5alvW3C8LrWHPTuWIug==
graphql-codegen-typescript-template@^0.13.0:
graphql-codegen-typescript-resolvers-template@^0.13.0:
version "0.13.0"
resolved "https://registry.yarnpkg.com/graphql-codegen-typescript-resolvers-template/-/graphql-codegen-typescript-resolvers-template-0.13.0.tgz#fd525e5199d15714f7cb079b7b7b44dd5ba3a531"
integrity sha512-guaQ+xbg+18TqiBSXWpgKf88tvoPaOtLkExhW5eMQnfBJ7PpX3AcOjExb+AKsQAH9DK6zL4n+txU7WeUfzGDbA==
dependencies:
graphql-codegen-typescript-template "0.13.0"
graphql-codegen-typescript-template@0.13.0, graphql-codegen-typescript-template@^0.13.0:
version "0.13.0"
resolved "https://registry.yarnpkg.com/graphql-codegen-typescript-template/-/graphql-codegen-typescript-template-0.13.0.tgz#41398687cbf279f1d97d8cfb8aa7c412bf0e7192"
integrity sha512-EYLd4v8toD+dpWHJsJliViaE52novhF9zbayFmY8IgLeHmYPVk2TfyS6CVvHmCoa0HTxOawvTY8a7UIgtnpw2w==