@spinnaker/kayenta 0.0.0-main-2

package/src/kayenta/metricStore/stackdriver/domain/IStackdriverCanaryMetricSetQueryConfig.ts

@@ -0,0 +1,9 @@
+import { ICanaryMetricSetQueryConfig } from 'kayenta/domain';
+
+export interface IStackdriverCanaryMetricSetQueryConfig extends ICanaryMetricSetQueryConfig {
+  metricType: string;
+  resourceType: string;
+  crossSeriesReducer: string;
+  perSeriesAligner: string;
+  groupByFields: string[];
+}

package/src/kayenta/metricStore/stackdriver/domain/IStackdriverMetricDescriptor.ts

@@ -0,0 +1,17 @@
+import { IMetricsServiceMetadata } from 'kayenta/domain/IMetricsServiceMetadata';
+
+export interface IStackdriverMetricDescriptor extends IMetricsServiceMetadata {
+  metricKind: string;
+  labels?: IStackdriverMetricDescriptorLabels[];
+  name: string;
+  displayName: string;
+  type: string;
+  description: string;
+  unit: string;
+  valueType: string;
+}
+
+export interface IStackdriverMetricDescriptorLabels {
+  description: string;
+  key: string;
+}

package/src/kayenta/metricStore/stackdriver/index.ts

@@ -0,0 +1,12 @@
+import { ICanaryMetricConfig } from 'kayenta/domain/ICanaryConfig';
+import { get } from 'lodash';
+
+import StackdriverMetricConfigurer from './metricConfigurer';
+import metricStoreConfigStore from '../metricStoreConfig.service';
+
+metricStoreConfigStore.register({
+  name: 'stackdriver',
+  metricConfigurer: StackdriverMetricConfigurer,
+  queryFinder: (metric: ICanaryMetricConfig) => get(metric, 'query.metricType', ''),
+  useTemplates: true,
+});

package/src/kayenta/metricStore/stackdriver/metricConfigurer.tsx

@@ -0,0 +1,144 @@
+import * as Creators from 'kayenta/actions/creators';
+import { ICanaryMetricConfig } from 'kayenta/domain/ICanaryConfig';
+import { DISABLE_EDIT_CONFIG, DisableableReactSelect } from 'kayenta/layout/disableable';
+import FormRow from 'kayenta/layout/formRow';
+import { IUpdateListPayload, List } from 'kayenta/layout/list';
+import { ICanaryState } from 'kayenta/reducers';
+import { get } from 'lodash';
+import * as React from 'react';
+import { connect } from 'react-redux';
+import { Option } from 'react-select';
+import { Action } from 'redux';
+
+import { IStackdriverCanaryMetricSetQueryConfig } from './domain/IStackdriverCanaryMetricSetQueryConfig';
+import StackdriverMetricTypeSelector from './metricTypeSelector';
+
+interface IStackdriverMetricConfigurerStateProps {
+  editingMetric: ICanaryMetricConfig;
+}
+
+interface IStackdriverMetricConfigurerDispatchProps {
+  updateStackdriverQueryField: <T extends keyof IStackdriverCanaryMetricSetQueryConfig>(
+    field: keyof IStackdriverCanaryMetricSetQueryConfig,
+    value: Option<IStackdriverCanaryMetricSetQueryConfig[T]>,
+  ) => void;
+  updateGroupBy: (payload: IUpdateListPayload) => void;
+}
+
+// TODO(dpeach): externalize these values.
+const RESOURCE_TYPES = [
+  'gce_instance',
+  'aws_ec2_instance',
+  'gae_app',
+  'k8s_container',
+  'k8s_pod',
+  'k8s_node',
+  'gke_container',
+  'https_lb_rule',
+  'global',
+];
+
+const CROSS_SERIES_REDUCERS = [
+  'REDUCE_NONE',
+  'REDUCE_MEAN',
+  'REDUCE_MIN',
+  'REDUCE_MAX',
+  'REDUCE_SUM',
+  'REDUCE_COUNT_TRUE',
+  'REDUCE_COUNT_FALSE',
+  'REDUCE_FRACTION_TRUE',
+  'REDUCE_PERCENTILE_99',
+  'REDUCE_PERCENTILE_95',
+  'REDUCE_PERCENTILE_50',
+  'REDUCE_PERCENTILE_05',
+];
+
+const PER_SERIES_ALIGNERS = [
+  'ALIGN_NONE',
+  'ALIGN_DELTA',
+  'ALIGN_RATE',
+  'ALIGN_INTERPOLATE',
+  'ALIGN_NEXT_OLDER',
+  'ALIGN_MIN',
+  'ALIGN_MAX',
+  'ALIGN_MEAN',
+  'ALIGN_COUNT',
+  'ALIGN_SUM',
+  'ALIGN_STDDEV',
+  'ALIGN_COUNT_TRUE',
+  'ALIGN_COUNT_FALSE',
+  'ALIGN_FRACTION_TRUE',
+  'ALIGN_PERCENTILE_99',
+  'ALIGN_PERCENTILE_95',
+  'ALIGN_PERCENTILE_50',
+  'ALIGN_PERCENTILE_05',
+  'ALIGN_PERCENT_CHANGE',
+];
+
+const STACKDRIVER_HELP_ID_PREFIX = 'stackdriver';
+
+const toReactSelectOptions = (values: string[]): Array<Option<string>> =>
+  values.map((value) => ({ value, label: value }));
+
+/*
+ * Component for configuring a Stackdriver metric.
+ * */
+function StackdriverMetricConfigurer({
+  editingMetric,
+  updateGroupBy,
+  updateStackdriverQueryField,
+}: IStackdriverMetricConfigurerStateProps & IStackdriverMetricConfigurerDispatchProps) {
+  return (
+    <>
+      <FormRow label="Resource Type" helpId={`${STACKDRIVER_HELP_ID_PREFIX}.resourceType`} inputOnly={true}>
+        <DisableableReactSelect
+          value={get(editingMetric, 'query.resourceType')}
+          options={toReactSelectOptions(RESOURCE_TYPES)}
+          onChange={(option: Option<string>) => updateStackdriverQueryField('resourceType', option)}
+          disabledStateKeys={[DISABLE_EDIT_CONFIG]}
+        />
+      </FormRow>
+      <FormRow label="Metric Type" helpId={`${STACKDRIVER_HELP_ID_PREFIX}.metricType`} inputOnly={true}>
+        <StackdriverMetricTypeSelector
+          value={get(editingMetric, 'query.metricType', '')}
+          onChange={(option: Option<string>) => updateStackdriverQueryField('metricType', option)}
+        />
+      </FormRow>
+      <FormRow label="Group By" helpId={`${STACKDRIVER_HELP_ID_PREFIX}.groupBy`}>
+        <List list={editingMetric.query.groupByFields || []} actionCreator={updateGroupBy} />
+      </FormRow>
+      <FormRow label="Aligner" helpId={`${STACKDRIVER_HELP_ID_PREFIX}.perSeriesAligner`} inputOnly={true}>
+        <DisableableReactSelect
+          value={get(editingMetric, 'query.perSeriesAligner')}
+          options={toReactSelectOptions(PER_SERIES_ALIGNERS)}
+          onChange={(option: Option<string>) => updateStackdriverQueryField('perSeriesAligner', option)}
+          disabledStateKeys={[DISABLE_EDIT_CONFIG]}
+        />
+      </FormRow>
+      <FormRow label="Reducer" helpId={`${STACKDRIVER_HELP_ID_PREFIX}.crossSeriesReducer`} inputOnly={true}>
+        <DisableableReactSelect
+          value={get(editingMetric, 'query.crossSeriesReducer')}
+          options={toReactSelectOptions(CROSS_SERIES_REDUCERS)}
+          onChange={(option: Option<string>) => updateStackdriverQueryField('crossSeriesReducer', option)}
+          disabledStateKeys={[DISABLE_EDIT_CONFIG]}
+        />
+      </FormRow>
+    </>
+  );
+}
+
+function mapStateToProps(state: ICanaryState): IStackdriverMetricConfigurerStateProps {
+  return {
+    editingMetric: state.selectedConfig.editingMetric,
+  };
+}
+
+function mapDispatchToProps(dispatch: (action: Action & any) => void): IStackdriverMetricConfigurerDispatchProps {
+  return {
+    updateStackdriverQueryField: (field, option) =>
+      dispatch(Creators.updateStackdriverMetricResourceField({ field, value: option && option.value })),
+    updateGroupBy: (payload) => dispatch(Creators.updateStackdriverGroupBy(payload)),
+  };
+}
+
+export default connect(mapStateToProps, mapDispatchToProps)(StackdriverMetricConfigurer);

package/src/kayenta/metricStore/stackdriver/metricTypeSelector.spec.tsx

@@ -0,0 +1,92 @@
+import { mountWithState, mountWithStore } from 'enzyme-redux';
+import * as Actions from 'kayenta/actions';
+import * as React from 'react';
+import { connect } from 'react-redux';
+import Select, { Option, ReactSelectProps } from 'react-select';
+import { createMockStore } from 'redux-test-utils';
+
+import { noop } from '@spinnaker/core';
+
+import { mapDispatchToProps, StackdriverMetricTypeSelector } from './metricTypeSelector';
+
+describe('<StackdriverMetricTypeSelector />', () => {
+  let Component: any;
+  let state: any;
+
+  beforeEach(() => {
+    state = {
+      descriptors: [
+        {
+          description: 'Delta count of disk read IO operations.',
+          metricKind: 'DELTA',
+          type: 'compute.googleapis.com/disk/read_ops_count',
+          name: 'projects/my-project/metricDescriptors/compute.googleapis.com/disk/read_ops_count',
+          unit: '1',
+          valueType: 'INT64',
+          displayName: 'Disk read operations',
+        },
+        {
+          description: 'Delta count of throttled read operations',
+          metricKind: 'DELTA',
+          type: 'compute.googleapis.com/disk/throttled_read_ops_count',
+          name: 'projects/my-project/metricDescriptors/compute.googleapis.com/disk/throttled_read_ops_count',
+          unit: '1',
+          valueType: 'INT64',
+          displayName: 'Throttled read operations',
+        },
+      ],
+      loading: false,
+    };
+
+    Component = connect(
+      (s, ownProps) => ({
+        ...s,
+        ...ownProps,
+      }),
+      mapDispatchToProps,
+    )(StackdriverMetricTypeSelector);
+  });
+
+  it('builds options from input descriptors', () => {
+    const component = mountWithState(
+      <Component value="compute.googleapis.com/disk/read_ops_count" onChange={noop} />,
+      state,
+    );
+
+    const allProps: any = component.find(Select).first().props();
+
+    expect(allProps.options.map((o: Option) => o.value)).toEqual([
+      'compute.googleapis.com/disk/read_ops_count',
+      'compute.googleapis.com/disk/throttled_read_ops_count',
+    ]);
+  });
+
+  it('queries for metric descriptors matching selected metric type on component mount', () => {
+    const store = createMockStore(state);
+    mountWithStore(<Component value="compute.googleapis.com/disk/read_ops_count" onChange={noop} />, store);
+
+    expect(
+      store.isActionDispatched({
+        type: Actions.UPDATE_STACKDRIVER_METRIC_DESCRIPTOR_FILTER,
+        payload: { filter: 'compute.googleapis.com/disk/read_ops_count' },
+      }),
+    ).toEqual(true);
+  });
+
+  it('queries for metric descriptors on input change', () => {
+    const store = createMockStore(state);
+    const component = mountWithStore(
+      <Component value="compute.googleapis.com/disk/read_ops_count" onChange={noop} />,
+      store,
+    );
+    const allProps: ReactSelectProps = component.find(Select).props();
+    allProps.onInputChange('redis');
+
+    expect(
+      store.isActionDispatched({
+        type: Actions.UPDATE_STACKDRIVER_METRIC_DESCRIPTOR_FILTER,
+        payload: { filter: 'redis' },
+      }),
+    ).toEqual(true);
+  });
+});

package/src/kayenta/metricStore/stackdriver/metricTypeSelector.tsx

@@ -0,0 +1,113 @@
+import * as Creators from 'kayenta/actions/creators';
+import { DISABLE_EDIT_CONFIG, DisableableReactSelect } from 'kayenta/layout/disableable';
+import { ICanaryState } from 'kayenta/reducers';
+import { AsyncRequestState } from 'kayenta/reducers/asyncRequest';
+import * as React from 'react';
+import { connect } from 'react-redux';
+import { Option } from 'react-select';
+import { Dispatch } from 'redux';
+
+import { IStackdriverMetricDescriptor } from './domain/IStackdriverMetricDescriptor';
+
+export interface IStackdriverMetricTypeSelectorDispatchProps {
+  load: (filter: string) => void;
+}
+
+export interface IStackdriverMetricTypeSelectorStateProps {
+  descriptors: IStackdriverMetricDescriptor[];
+  loading: boolean;
+}
+
+export interface IStackdriverMetricTypeSelectorOwnProps {
+  value: string;
+  onChange: (option: Option) => void;
+}
+
+type IStackdriverMetricTypeProps = IStackdriverMetricTypeSelectorDispatchProps &
+  IStackdriverMetricTypeSelectorStateProps &
+  IStackdriverMetricTypeSelectorOwnProps;
+
+const MetricField = ({
+  descriptor,
+  field,
+  label,
+}: {
+  descriptor: IStackdriverMetricDescriptor;
+  field: keyof IStackdriverMetricDescriptor;
+  label: string;
+}) => {
+  if (!descriptor || !descriptor[field]) {
+    return null;
+  }
+  return (
+    <div>
+      <strong>{label}: </strong>
+      {descriptor[field]}
+    </div>
+  );
+};
+
+export class StackdriverMetricTypeSelector extends React.Component<IStackdriverMetricTypeProps> {
+  public componentDidMount() {
+    this.props.load(this.props.value);
+  }
+
+  public render() {
+    const { loading, load, descriptors, value, onChange } = this.props;
+
+    let options: Option[] = descriptors.map((d) => ({ label: d.type, value: d.type }));
+    if (value && options.every((o) => o.value !== value)) {
+      options = options.concat({ label: value, value });
+    }
+
+    return (
+      <DisableableReactSelect
+        isLoading={loading}
+        options={options}
+        onChange={onChange}
+        value={value}
+        optionRenderer={(option: Option<string>) => {
+          const descriptor = descriptors.find((d) => d.type === option.value);
+          if (!descriptor) {
+            return <span>{option.label}</span>;
+          }
+
+          return (
+            <>
+              <MetricField descriptor={descriptor} field="type" label="Metric" />
+              <MetricField descriptor={descriptor} field="description" label="Description" />
+              <MetricField descriptor={descriptor} field="unit" label="Unit" />
+              <MetricField descriptor={descriptor} field="metricKind" label="Kind" />
+              <MetricField descriptor={descriptor} field="valueType" label="Value type" />
+            </>
+          );
+        }}
+        placeholder={'Enter at least three characters to search.'}
+        onInputChange={(input) => {
+          load(input);
+          return input;
+        }}
+        disabledStateKeys={[DISABLE_EDIT_CONFIG]}
+      />
+    );
+  }
+}
+
+export const mapStateToProps = (state: ICanaryState, ownProps: IStackdriverMetricTypeSelectorOwnProps) => {
+  const descriptors = state.data.metricsServiceMetadata.data as IStackdriverMetricDescriptor[];
+  return {
+    descriptors,
+    loading: state.data.metricsServiceMetadata.load === AsyncRequestState.Requesting,
+    ...ownProps,
+  };
+};
+
+export const mapDispatchToProps = (dispatch: Dispatch<ICanaryState>) => {
+  return {
+    load: (filter: string) => {
+      dispatch(Creators.updateStackdriverMetricDescriptorFilter({ filter }));
+    },
+  };
+};
+
+export default connect(mapStateToProps, mapDispatchToProps)(StackdriverMetricTypeSelector);

package/src/kayenta/middleware/actionInterceptor.ts

@@ -0,0 +1,29 @@
+import * as Creators from 'kayenta/actions/creators';
+import * as Actions from 'kayenta/actions/index';
+import { Action, Dispatch, Middleware, MiddlewareAPI } from 'redux';
+
+import { ICanaryState } from '../reducers/index';
+import { buildConfigCopy, buildNewConfig } from '../service/canaryConfig.service';
+
+// TODO: replace the `any` generic passed to MiddlewareAPI with ICanaryState. The Redux typings here are wrong.
+// Should be fixed in this PR: https://github.com/reactjs/redux/pull/2563
+export const actionInterceptingMiddleware: Middleware = (store: MiddlewareAPI<any>) => (
+  next: Dispatch<ICanaryState>,
+) => (action: Action & any) => {
+  switch (action.type) {
+    case Actions.CREATE_NEW_CONFIG: {
+      const newConfig = buildNewConfig(store.getState());
+      const newAction = Creators.selectConfig({ config: newConfig });
+      return next(newAction);
+    }
+
+    case Actions.COPY_SELECTED_CONFIG: {
+      const copiedConfig = buildConfigCopy(store.getState());
+      const newAction = Creators.selectConfig({ config: copiedConfig });
+      return next(newAction);
+    }
+
+    default:
+      return next(action);
+  }
+};

package/src/kayenta/middleware/asyncDispatch.ts

@@ -0,0 +1,37 @@
+import { Action, Dispatch, Middleware, MiddlewareAPI } from 'redux';
+
+import { ICanaryState } from '../reducers/index';
+
+/*
+ * Middleware for scheduling actions from within reducers.
+ * Provides every action with an `asyncDispatch` method.
+ * Actions provided to `asyncDispatch` will run after all reducers have completed.
+ * TODO: type actions to include `asyncDispatch`.
+ * */
+
+// TODO: replace the `any` generic passed to MiddlewareAPI with ICanaryState. The Redux typings here are wrong.
+// Should be fixed in this PR: https://github.com/reactjs/redux/pull/2563
+export const asyncDispatchMiddleware: Middleware = (store: MiddlewareAPI<any>) => (next: Dispatch<ICanaryState>) => (
+  action: Action & any,
+) => {
+  let syncActivityFinished = false;
+  let actionQueue: Action[] = [];
+
+  const flushQueue = () => {
+    actionQueue.forEach((a) => store.dispatch(a));
+    actionQueue = [];
+  };
+
+  const asyncDispatch = (a: Action & any) => {
+    actionQueue.push(a);
+    if (syncActivityFinished) {
+      flushQueue();
+    }
+  };
+
+  const nextAction = next({ ...action, asyncDispatch });
+  syncActivityFinished = true;
+  flushQueue();
+
+  return nextAction;
+};

package/src/kayenta/middleware/epics.ts

@@ -0,0 +1,211 @@
+import * as Actions from 'kayenta/actions';
+import * as Creators from 'kayenta/actions/creators';
+import { ICanaryConfigUpdateResponse, KayentaAccountType } from 'kayenta/domain';
+import { ICanaryState } from 'kayenta/reducers';
+import { runSelector } from 'kayenta/selectors';
+import {
+  createCanaryConfig,
+  deleteCanaryConfig,
+  getCanaryConfigById,
+  listKayentaAccounts,
+  mapStateToConfig,
+  updateCanaryConfig,
+} from 'kayenta/service/canaryConfig.service';
+import { listMetricsServiceMetadata } from 'kayenta/service/metricsServiceMetadata.service';
+import { Action, MiddlewareAPI } from 'redux';
+import { combineEpics, createEpicMiddleware, EpicMiddleware } from 'redux-observable';
+import { Observable } from 'rxjs/Observable';
+import 'rxjs/add/observable/concat';
+import 'rxjs/add/observable/forkJoin';
+import 'rxjs/add/observable/fromPromise';
+import 'rxjs/add/operator/catch';
+import 'rxjs/add/operator/concatMap';
+import 'rxjs/add/operator/debounceTime';
+import 'rxjs/add/operator/filter';
+import 'rxjs/add/operator/map';
+import 'rxjs/add/operator/mapTo';
+
+import { ReactInjector } from '@spinnaker/core';
+
+import { getCanaryRun, getMetricSetPair } from '../service/canaryRun.service';
+
+const typeMatches = (...actions: string[]) => (action: Action & any) => actions.includes(action.type);
+
+const loadConfigEpic = (action$: Observable<Action & any>) =>
+  action$.filter(typeMatches(Actions.LOAD_CONFIG_REQUEST, Actions.SAVE_CONFIG_SUCCESS)).concatMap((action) =>
+    Observable.fromPromise(getCanaryConfigById(action.payload.id))
+      .map((config) => Creators.loadConfigSuccess({ config }))
+      .catch((error) => Observable.of(Creators.loadConfigFailure({ error }))),
+  );
+
+const selectConfigEpic = (action$: Observable<Action & any>) =>
+  action$
+    .filter(typeMatches(Actions.LOAD_CONFIG_SUCCESS))
+    .map((action) => Creators.selectConfig({ config: action.payload.config }));
+
+const saveConfigEpic = (action$: Observable<Action & any>, store: MiddlewareAPI<ICanaryState>) =>
+  action$.filter(typeMatches(Actions.SAVE_CONFIG_REQUEST)).concatMap(() => {
+    const config = mapStateToConfig(store.getState());
+    let saveAction: PromiseLike<ICanaryConfigUpdateResponse>;
+    if (config.isNew) {
+      delete config.isNew;
+      saveAction = createCanaryConfig(config);
+    } else {
+      saveAction = updateCanaryConfig(config);
+    }
+
+    return Observable.fromPromise(saveAction)
+      .concatMap(({ canaryConfigId }) =>
+        Observable.forkJoin(
+          ReactInjector.$state.go('^.configDetail', { id: canaryConfigId, copy: false, new: false }),
+          store.getState().data.application.getDataSource('canaryConfigs').refresh(true),
+        ).mapTo(Creators.saveConfigSuccess({ id: canaryConfigId })),
+      )
+      .catch((error: Error) => Observable.of(Creators.saveConfigFailure({ error })));
+  });
+
+const deleteConfigRequestEpic = (action$: Observable<Action & any>, store: MiddlewareAPI<ICanaryState>) =>
+  action$.filter(typeMatches(Actions.DELETE_CONFIG_REQUEST)).concatMap(() =>
+    Observable.fromPromise(deleteCanaryConfig(store.getState().selectedConfig.config.id))
+      .mapTo(Creators.deleteConfigSuccess())
+      .catch((error: Error) => Observable.of(Creators.deleteConfigFailure({ error }))),
+  );
+
+const deleteConfigSuccessEpic = (action$: Observable<Action & any>, store: MiddlewareAPI<ICanaryState>) =>
+  action$
+    .filter(typeMatches(Actions.DELETE_CONFIG_SUCCESS))
+    .concatMap(() =>
+      Observable.forkJoin(
+        ReactInjector.$state.go('^.configDefault'),
+        // TODO: handle config summary load failure (in general, not just here).
+        store.getState().data.application.getDataSource('canaryConfigs').refresh(true),
+      ),
+    )
+    .mapTo(Creators.closeDeleteConfigModal());
+
+const loadCanaryRunRequestEpic = (action$: Observable<Action & any>) =>
+  action$.filter(typeMatches(Actions.LOAD_RUN_REQUEST)).concatMap((action) =>
+    Observable.fromPromise(getCanaryRun(action.payload.configId, action.payload.runId))
+      .map((run) => Creators.loadRunSuccess({ run }))
+      .catch((error: Error) => Observable.of(Creators.loadRunFailure({ error }))),
+  );
+
+const loadMetricSetPairEpic = (action$: Observable<Action & any>, store: MiddlewareAPI<ICanaryState>) =>
+  action$.filter(typeMatches(Actions.LOAD_METRIC_SET_PAIR_REQUEST)).concatMap((action) => {
+    const run = runSelector(store.getState());
+    return Observable.fromPromise(getMetricSetPair(run.metricSetPairListId, action.payload.pairId))
+      .map((metricSetPair) => Creators.loadMetricSetPairSuccess({ metricSetPair }))
+      .catch((error: Error) => Observable.of(Creators.loadMetricSetPairFailure({ error })));
+  });
+
+const updatePrometheusMetricDescriptionFilterEpic = (action$: Observable<Action & any>) =>
+  action$
+    .filter(typeMatches(Actions.UPDATE_PROMETHEUS_METRIC_DESCRIPTOR_FILTER))
+    .filter((action) => action.payload.filter && action.payload.filter.length > 2)
+    .debounceTime(200 /* milliseconds */)
+    .map((action) => {
+      return Creators.loadMetricsServiceMetadataRequest({
+        filter: action.payload.filter,
+        metricsAccountName: action.payload.metricsAccountName,
+      });
+    });
+
+const updateStackdriverMetricDescriptionFilterEpic = (
+  action$: Observable<Action & any>,
+  store: MiddlewareAPI<ICanaryState>,
+) =>
+  action$
+    .filter(typeMatches(Actions.UPDATE_STACKDRIVER_METRIC_DESCRIPTOR_FILTER))
+    .filter((action) => action.payload.filter && action.payload.filter.length > 2)
+    .debounceTime(200 /* milliseconds */)
+    .map((action) => {
+      const [metricsAccountName] = store
+        .getState()
+        .data.kayentaAccounts.data.filter(
+          (account) =>
+            account.supportedTypes.includes(KayentaAccountType.MetricsStore) &&
+            account.metricsStoreType === 'stackdriver',
+        )
+        .map((account) => account.name);
+
+      return Creators.loadMetricsServiceMetadataRequest({
+        filter: action.payload.filter,
+        metricsAccountName,
+      });
+    });
+
+const updateGraphiteMetricDescriptionFilterEpic = (
+  action$: Observable<Action & any>,
+  store: MiddlewareAPI<ICanaryState>,
+) =>
+  action$
+    .filter(typeMatches(Actions.UPDATE_GRAPHITE_METRIC_DESCRIPTOR_FILTER))
+    .filter((action) => action.payload.filter && action.payload.filter.length > 2)
+    .debounceTime(200 /* milliseconds */)
+    .map((action) => {
+      const [metricsAccountName] = store
+        .getState()
+        .data.kayentaAccounts.data.filter(
+          (account) => account.supportedTypes.includes(KayentaAccountType.MetricsStore) && account.type === 'graphite',
+        )
+        .map((account) => account.name);
+
+      return Creators.loadMetricsServiceMetadataRequest({
+        filter: action.payload.filter,
+        metricsAccountName,
+      });
+    });
+
+const updateDatadogMetricDescriptionFilterEpic = (
+  action$: Observable<Action & any>,
+  store: MiddlewareAPI<ICanaryState>,
+) =>
+  action$
+    .filter(typeMatches(Actions.UPDATE_DATADOG_METRIC_DESCRIPTOR_FILTER))
+    .filter((action) => action.payload.filter && action.payload.filter.length > 2)
+    .debounceTime(200 /* milliseconds */)
+    .map((action) => {
+      const [metricsAccountName] = store
+        .getState()
+        .data.kayentaAccounts.data.filter(
+          (account) => account.supportedTypes.includes(KayentaAccountType.MetricsStore) && account.type === 'datadog',
+        )
+        .map((account) => account.name);
+
+      return Creators.loadMetricsServiceMetadataRequest({
+        filter: action.payload.filter,
+        metricsAccountName,
+      });
+    });
+
+const loadMetricsServiceMetadataEpic = (action$: Observable<Action & any>) =>
+  action$.filter(typeMatches(Actions.LOAD_METRICS_SERVICE_METADATA_REQUEST)).concatMap((action) => {
+    return Observable.fromPromise(listMetricsServiceMetadata(action.payload.filter, action.payload.metricsAccountName))
+      .map((data) => Creators.loadMetricsServiceMetadataSuccess({ data }))
+      .catch((error: Error) => Observable.of(Creators.loadMetricsServiceMetadataFailure({ error })));
+  });
+
+const loadKayentaAccountsEpic = (action$: Observable<Action & any>) =>
+  action$.filter(typeMatches(Actions.LOAD_KAYENTA_ACCOUNTS_REQUEST, Actions.INITIALIZE)).concatMap(() =>
+    Observable.fromPromise(listKayentaAccounts())
+      .map((accounts) => Creators.loadKayentaAccountsSuccess({ accounts }))
+      .catch((error: Error) => Observable.of(Creators.loadKayentaAccountsFailure({ error }))),
+  );
+
+const rootEpic = combineEpics(
+  loadConfigEpic,
+  selectConfigEpic,
+  saveConfigEpic,
+  deleteConfigRequestEpic,
+  deleteConfigSuccessEpic,
+  loadCanaryRunRequestEpic,
+  loadMetricSetPairEpic,
+  updateGraphiteMetricDescriptionFilterEpic,
+  updatePrometheusMetricDescriptionFilterEpic,
+  updateStackdriverMetricDescriptionFilterEpic,
+  updateDatadogMetricDescriptionFilterEpic,
+  loadMetricsServiceMetadataEpic,
+  loadKayentaAccountsEpic,
+);
+
+export const epicMiddleware: EpicMiddleware<Action & any, ICanaryState> = createEpicMiddleware(rootEpic);

package/src/kayenta/middleware/index.ts

@@ -0,0 +1,3 @@
+export * from './actionInterceptor';
+export * from './asyncDispatch';
+export * from './epics';