[Alerting] add a framework-provided mustache template variable that lists all the available variables and their values

[pmuellr]

For KIbana alerts, when you create actions to be executed when the alert is triggered, the parameters of the alert can be replaced with "context variables" provided by the application. You can see these in the alert flyout, here - the small red-outlined button will display the larger list of variables shown in the large red-outlined button:

It's difficult to keep this list up-to-date with the alerts, and in some cases may be impossible, as the alert can make variables available dynamically.

It would be nice to have one of these "context variables" that actually showed you ALL of the context variables, so you could use it an alert to see what all the values were, while crafting your actions.

Here's a quick hack that illustrates what we could do. The set of variables we pass to mustache to fill in the action parameter template is returned here, for the index threshold alert:

kibana/x-pack/plugins/alerting_builtins/server/alert_types/index_threshold/action_context.ts

Line 68 in bcca933

return { ...baseContext, title, message };

Mustache has a couple of ways of allowing functions to be used in the variables object - you can either pass a named function in the object, and it will be invoked when accessed, or you can make use of toString() to produce a nicer version of your object than what Mustache would typically provide. Eg, if you pass {{context}} as an action parameter, the result will be [object Object].

Here's a replacement for that last line above, which adds a toString() to the context variable itself, which returns a JSON version of itself:

  const actionContext: ActionContext = { ...baseContext, title, message };
  actionContext.toString = () => JSON.stringify(actionContext);
  return actionContext;

With this code, the result of using {{context}} will no longer be [object Object], but will be the following (I've split lines for readability):

{
  "date": "2020-08-20T20:03:36.378Z",
  "group": "host-1",
  "value": 0.800000011920929,
  "title": "alert es-apm-sys-sim threshold group host-1 exceeded threshold",
  "message": "alert es-apm-sys-sim threshold group host-1 value 0.800000011920929 exceeded threshold avg(system.cpu.total.norm.pct) > 0.8 over 5s on 2020-08-20T20:03:36.378Z"
}

Sort of seems we should provide some top-level variable, that would include all the other top-level variables (all the alert* variables, the params, context, and state objects, etc), as a flattened list (in the case of context variables being objects with properties themselves), with a fixed name, that we make available for all the templating uses.

I'm not expecting this would be used in a "real" alert, but while creating your alerts to see what variables are available. Perhaps an appropriate name for this "variable" would be variables or such.

[elasticmachine]

Pinging @elastic/kibana-alerting-services (Team:Alerting Services)

[pmuellr]

There's an implementation of this in not-yet-merged-ATM PR #83919, since I was already in that code and this was easy enough to add.

[pmuellr]

I had some code this in PR #83919 for a while, but am taking it out as that PR is getting too big. I'll keep a branch of that though, and do a follow-on PR for this.

For reference, here's the code for it:

import { isPlainObject } from 'lodash';

type Variables = Record<string, unknown>;

// return variables cloned, with a toString() added to objects
function augmentObjectVariables(variables: Variables): Variables {
  const result = JSON.parse(JSON.stringify(variables));
  addToStringDeep(result);
  return result;
}

function addToStringDeep(object: unknown): void {
  // for objects, add a toString method, and then walk
  if (isNonNullObject(object)) {
    if (!object.hasOwnProperty('toString')) {
      object.toString = () => JSON.stringify(object);
    }
    Object.values(object).forEach((value) => addToStringDeep(value));
  }

  // walk arrays, but don't add a toString() as mustache already does something
  if (Array.isArray(object)) {
    object.forEach((element) => addToStringDeep(element));
    return;
  }
}

function isNonNullObject(object: unknown): object is Record<string, unknown> {
  if (object == null) return false;
  if (typeof object !== 'object') return false;
  if (!isPlainObject(object)) return false;
  return true;
}

Here's a test for it:

  describe('augmented object variables', () => {
    const deepVariables = {
      a: 1,
      b: { c: 2, d: [3, 4] },
      e: [5, { f: 6, g: 7 }],
    };
    expect(renderMustacheObject({ x: '{{a}} - {{b}} -- {{e}} ' }, deepVariables))
      .toMatchInlineSnapshot(`
      Object {
        "x": "1 - {\\"c\\":2,\\"d\\":[3,4]} -- 5,{\\"f\\":6,\\"g\\":7} ",
      }
    `);

    const expected = '1 - {"c":2,"d":[3,4]} -- 5,{"f":6,"g":7}';
    expect(renderMustacheString('{{a}} - {{b}} -- {{e}}', deepVariables, 'none')).toEqual(expected);
  });