Merge branch 'main' into fix/enable-prerelease-suite

Author: jen-huang

docs/api/alerting/create_rule.asciidoc

@@ -224,7 +224,7 @@ The API returns the following:
   "execution_status": {
     "last_execution_date": "2022-06-08T17:20:31.632Z",
     "status": "pending"
-  }
+  },
   "actions": [
     {
       "group": "threshold met",

src/plugins/chart_expressions/expression_partition_vis/public/utils/filter_helpers.test.ts

@@ -7,7 +7,12 @@
  */
 import { Datatable, DatatableColumn } from '@kbn/expressions-plugin/public';
 import { fieldFormatsMock } from '@kbn/field-formats-plugin/common/mocks';
-import { getFilterClickData, getFilterEventData, getFilterPopoverTitle } from './filter_helpers';
+import {
+  getFilterClickData,
+  getFilterEventData,
+  getFilterPopoverTitle,
+  getAccessor,
+} from './filter_helpers';
 import { createMockBucketColumns, createMockVisData, createMockPieParams } from '../mocks';
 import { consolidateMetricColumns } from '../../common/utils';
 import { LayerValue } from '@elastic/charts';
@@ -267,6 +272,26 @@ describe('getFilterEventData', () => {
   });
 });
 
+describe('getAccessor', () => {
+  it('returns the correct accessor for ExpressionValueVisDimension', () => {
+    const accessor = getAccessor(visParams.dimensions.buckets, 2);
+    expect(accessor).toStrictEqual({
+      accessor: 2,
+      format: {
+        id: 'terms',
+        params: { id: 'boolean', missingBucketLabel: 'Missing', otherBucketLabel: 'Other' },
+      },
+      type: 'vis_dimension',
+    });
+  });
+
+  it('returns the correct accessor for strings', () => {
+    const buckets = ['bucket1', 'bucket2'];
+    const accessor = getAccessor(buckets, 0);
+    expect(accessor).toStrictEqual('bucket1');
+  });
+});
+
 describe('getFilterPopoverTitle', () => {
   it('returns the series key if no buckets', () => {
     const series = {

src/plugins/chart_expressions/expression_partition_vis/public/utils/filter_helpers.ts

@@ -12,7 +12,7 @@ import { DataPublicPluginStart } from '@kbn/data-plugin/public';
 import { ValueClickContext } from '@kbn/embeddable-plugin/public';
 import { getFormatByAccessor } from '@kbn/visualizations-plugin/common/utils';
 import type { FieldFormat, FormatFactory } from '@kbn/field-formats-plugin/common';
-import { BucketColumns, PartitionVisParams } from '../../common/types';
+import { BucketColumns, PartitionVisParams, Dimensions } from '../../common/types';
 import { FilterEvent } from '../types';
 
 export const canFilter = async (
@@ -131,6 +131,13 @@ export const getSeriesValueColumnIndex = (value: string, visData: Datatable): nu
   return visData.columns.findIndex(({ id }) => !!visData.rows.find((r) => r[id] === value));
 };
 
+export const getAccessor = (buckets: Dimensions['buckets'], index: number) => {
+  const accessorForDimensionBuckets = buckets?.find((b) => {
+    return typeof b !== 'string' && b.accessor === index;
+  });
+  return accessorForDimensionBuckets || buckets?.[index];
+};
+
 export const getFilterPopoverTitle = (
   visParams: PartitionVisParams,
   visData: Datatable,
@@ -140,7 +147,7 @@ export const getFilterPopoverTitle = (
 ) => {
   let formattedTitle = '';
   if (visParams.dimensions.buckets) {
-    const accessor = visParams.dimensions.buckets[columnIndex];
+    const accessor = getAccessor(visParams.dimensions.buckets, columnIndex);
     formattedTitle = accessor
       ? formatter(getFormatByAccessor(accessor, visData.columns)).convert(seriesKey)
       : '';

x-pack/plugins/ml/public/application/components/anomalies_table/links_menu.tsx

@@ -227,16 +227,18 @@ export const LinksMenuUI = (props: LinksMenuProps) => {
         // Start from the previous hour.
         earliestMoment.subtract(1, 'h');
       }
-      let latestMoment = moment(record.timestamp).add(record.bucket_span, 's');
+
+      const latestMoment = moment(record.timestamp).add(record.bucket_span, 's');
       if (props.isAggregatedData === true) {
-        latestMoment = moment(record.timestamp).endOf(interval);
         if (interval === 'hour') {
           // Show to the end of the next hour.
-          latestMoment.add(1, 'h'); // e.g. 2016-02-08T18:59:59.999Z
+          latestMoment.add(1, 'h');
         }
+        latestMoment.subtract(1, 'ms').endOf(interval); // e.g. 2016-02-08T18:59:59.999Z
       }
+
       const from = timeFormatter(earliestMoment.unix() * 1000); // e.g. 2016-02-08T16:00:00.000Z
-      const to = timeFormatter(latestMoment.unix() * 1000);
+      const to = timeFormatter(latestMoment.unix() * 1000); // e.g. 2016-02-08T18:59:59.000Z
 
       let kqlQuery = '';
 
@@ -315,16 +317,16 @@ export const LinksMenuUI = (props: LinksMenuProps) => {
     }
 
     if (configuredUrlValue.includes('$latest$')) {
-      let latestMoment = moment(timestamp).add(record.bucket_span, 's');
+      const latestMoment = moment(timestamp).add(record.bucket_span, 's');
       if (timeRangeInterval !== null) {
         latestMoment.add(timeRangeInterval);
       } else {
         if (isAggregatedData === true) {
-          latestMoment = moment(timestamp).endOf(interval);
           if (interval === 'hour') {
             // Show to the end of the next hour.
             latestMoment.add(1, 'h'); // e.g. 2016-02-08T18:59:59.999Z
           }
+          latestMoment.subtract(1, 'ms').endOf(interval); // e.g. 2016-02-08T18:59:59.999Z
         }
       }
       record.latest = latestMoment.toISOString();

x-pack/plugins/stack_connectors/common/slack/constants.ts

@@ -0,0 +1,9 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+export const SLACK_CONNECTOR_ID = '.slack';
+export const SLACK_URL = 'https://slack.com/api/';

x-pack/plugins/stack_connectors/common/slack/schema.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { schema } from '@kbn/config-schema';
+
+export const SlackConfigSchema = schema.object({
+  type: schema.oneOf([schema.literal('webhook'), schema.literal('web_api')], {
+    defaultValue: 'webhook',
+  }),
+});
+
+export const SlackWebhookSecretsSchema = schema.object({
+  webhookUrl: schema.string({ minLength: 1 }),
+});
+export const SlackWebApiSecretsSchema = schema.object({
+  token: schema.string({ minLength: 1 }),
+});
+
+export const SlackSecretsSchema = schema.oneOf([
+  SlackWebhookSecretsSchema,
+  SlackWebApiSecretsSchema,
+]);
+
+export const ExecutorGetChannelsParamsSchema = schema.object({
+  subAction: schema.literal('getChannels'),
+});
+
+export const PostMessageSubActionParamsSchema = schema.object({
+  channels: schema.arrayOf(schema.string()),
+  text: schema.string(),
+});
+export const ExecutorPostMessageParamsSchema = schema.object({
+  subAction: schema.literal('postMessage'),
+  subActionParams: PostMessageSubActionParamsSchema,
+});
+
+export const WebhookParamsSchema = schema.object({
+  message: schema.string({ minLength: 1 }),
+});
+export const WebApiParamsSchema = schema.oneOf([
+  ExecutorGetChannelsParamsSchema,
+  ExecutorPostMessageParamsSchema,
+]);
+
+export const SlackParamsSchema = schema.oneOf([WebhookParamsSchema, WebApiParamsSchema]);

x-pack/plugins/stack_connectors/common/slack/types.ts

@@ -0,0 +1,57 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { TypeOf } from '@kbn/config-schema';
+import type { ActionTypeExecutorOptions as ConnectorTypeExecutorOptions } from '@kbn/actions-plugin/server/types';
+import type { ActionType as ConnectorType } from '@kbn/actions-plugin/server/types';
+import {
+  ExecutorPostMessageParamsSchema,
+  PostMessageSubActionParamsSchema,
+  SlackConfigSchema,
+  SlackSecretsSchema,
+  SlackWebhookSecretsSchema,
+  SlackWebApiSecretsSchema,
+  WebhookParamsSchema,
+  WebApiParamsSchema,
+} from './schema';
+
+export type SlackConfig = TypeOf<typeof SlackConfigSchema>;
+export type SlackSecrets = TypeOf<typeof SlackSecretsSchema>;
+
+export type PostMessageParams = TypeOf<typeof ExecutorPostMessageParamsSchema>;
+export type PostMessageSubActionParams = TypeOf<typeof PostMessageSubActionParamsSchema>;
+
+export type SlackWebhookSecrets = TypeOf<typeof SlackWebhookSecretsSchema>;
+export type SlackWebApiSecrets = TypeOf<typeof SlackWebApiSecretsSchema>;
+
+export type SlackWebhookExecutorOptions = ConnectorTypeExecutorOptions<
+  SlackConfig,
+  SlackWebhookSecrets,
+  WebhookParams
+>;
+export type SlackWebApiExecutorOptions = ConnectorTypeExecutorOptions<
+  SlackConfig,
+  SlackWebApiSecrets,
+  WebApiParams
+>;
+
+export type SlackExecutorOptions = ConnectorTypeExecutorOptions<
+  SlackConfig,
+  SlackSecrets,
+  WebhookParams | WebApiParams
+>;
+
+export type SlackConnectorType = ConnectorType<
+  SlackConfig,
+  SlackSecrets,
+  WebhookParams | WebApiParams,
+  unknown
+>;
+
+export type WebhookParams = TypeOf<typeof WebhookParamsSchema>;
+export type WebApiParams = TypeOf<typeof WebApiParamsSchema>;
+export type SlackActionParams = WebhookParams | WebApiParams;

x-pack/plugins/stack_connectors/public/connector_types/slack/slack.test.tsx

@@ -30,13 +30,16 @@ describe('connectorTypeRegistry.get() works', () => {
 });
 
 describe('slack action params validation', () => {
-  test('if action params validation succeeds when action params is valid', async () => {
+  test('should succeed when action params include valid message', async () => {
     const actionParams = {
       message: 'message {test}',
     };
 
     expect(await connectorTypeModel.validateParams(actionParams)).toEqual({
-      errors: { message: [] },
+      errors: {
+        message: [],
+        'subActionParams.channels': [],
+      },
     });
   });
 
@@ -48,6 +51,77 @@ describe('slack action params validation', () => {
     expect(await connectorTypeModel.validateParams(actionParams)).toEqual({
       errors: {
         message: ['Message is required.'],
+        'subActionParams.channels': [],
+      },
+    });
+  });
+
+  test('should succeed when action params include valid message and channels list', async () => {
+    const actionParams = {
+      subAction: 'postMessage',
+      subActionParams: { channels: ['general'], text: 'some text' },
+    };
+
+    expect(await connectorTypeModel.validateParams(actionParams)).toEqual({
+      errors: {
+        message: [],
+        'subActionParams.channels': [],
+      },
+    });
+  });
+
+  test('should fail when action params do not includes any channels', async () => {
+    const actionParams = {
+      subAction: 'postMessage',
+      subActionParams: { channels: [], text: 'some text' },
+    };
+
+    expect(await connectorTypeModel.validateParams(actionParams)).toEqual({
+      errors: {
+        message: [],
+        'subActionParams.channels': ['At least one selected channel is required.'],
+      },
+    });
+  });
+
+  test('should fail when channels field is missing in action params', async () => {
+    const actionParams = {
+      subAction: 'postMessage',
+      subActionParams: { text: 'some text' },
+    };
+
+    expect(await connectorTypeModel.validateParams(actionParams)).toEqual({
+      errors: {
+        message: [],
+        'subActionParams.channels': ['At least one selected channel is required.'],
+      },
+    });
+  });
+
+  test('should fail when field text doesnot exist', async () => {
+    const actionParams = {
+      subAction: 'postMessage',
+      subActionParams: { channels: ['general'] },
+    };
+
+    expect(await connectorTypeModel.validateParams(actionParams)).toEqual({
+      errors: {
+        message: ['Message is required.'],
+        'subActionParams.channels': [],
+      },
+    });
+  });
+
+  test('should fail when text is empty string', async () => {
+    const actionParams = {
+      subAction: 'postMessage',
+      subActionParams: { channels: ['general'], text: '' },
+    };
+
+    expect(await connectorTypeModel.validateParams(actionParams)).toEqual({
+      errors: {
+        message: ['Message is required.'],
+        'subActionParams.channels': [],
       },
     });
   });