datadog-mcp 5.8.0 → 5.8.2

package/dist/index.js

@@ -303622,7 +303622,8 @@ async function histogramEventsV2(api, params, limits, site) {
   const fullQuery = buildEventQuery({
     query: params.query,
     sources: params.sources,
-    tags: params.tags
+    tags: params.tags,
+    transitionType: params.transitionType
   });
   const cap = limits.maxEventsForHistogram;
   const perPage = Math.max(1, Math.min(1e3, cap));
@@ -304394,7 +304395,8 @@ histogram: Bucket events by local hour_of_day / day_of_week / day_of_month in th
                   tags,
                   bucket_by: histogramBucketBy,
                   timezone,
-                  cursor
+                  cursor,
+                  transitionType
                 },
                 limits,
                 site
@@ -304456,6 +304458,28 @@ function lookupVariable(path, variables) {
   return String(cursor);
 }
 var TAG_REGEX = /\{\{\s*([#^/>])?\s*([^}]*?)\s*\}\}/g;
+var TAG_CONDITIONAL_HEAD = /^(is_match|is_exact_match)\b/;
+var QUOTED_ARG_REGEX = /"([^"]*)"/g;
+function parseTagConditionalHead(body, prefix) {
+  const headMatch = TAG_CONDITIONAL_HEAD.exec(body);
+  if (!headMatch?.[1]) {
+    return null;
+  }
+  const conditional = headMatch[1];
+  const args = [];
+  QUOTED_ARG_REGEX.lastIndex = 0;
+  let arg;
+  while ((arg = QUOTED_ARG_REGEX.exec(body)) !== null) {
+    args.push(arg[1] ?? "");
+  }
+  const [variable, ...comparisons] = args;
+  if (variable === void 0 || variable === "" || comparisons.length === 0) {
+    throw unsupportedSyntaxError(
+      `${conditional} requires a quoted tag and at least one quoted comparison value (found {{${prefix}${body}}})`
+    );
+  }
+  return { conditional, variable, comparisons };
+}
 function parseBlocks(template) {
   const stack = [{ children: [] }];
   let cursor = 0;
@@ -304475,16 +304499,32 @@ function parseBlocks(template) {
       throw unsupportedSyntaxError(`partials are not supported (found {{> ${name}}})`);
     }
     if (prefix === "#" || prefix === "^") {
-      if (name.startsWith("each") || /\s/.test(name)) {
+      const tagHead = parseTagConditionalHead(name, prefix);
+      if (tagHead) {
+        stack.push({
+          children: [],
+          closer: {
+            kind: "tag",
+            conditional: tagHead.conditional,
+            negated: prefix === "^",
+            variable: tagHead.variable,
+            comparisons: tagHead.comparisons
+          }
+        });
+      } else if (name.startsWith("each") || /\s/.test(name)) {
         throw unsupportedSyntaxError(`loops are not supported (found {{${prefix}${name}}})`);
-      }
-      if (!SUPPORTED_SET.has(name)) {
+      } else if (!SUPPORTED_SET.has(name)) {
         throw unsupportedSyntaxError(`unknown conditional '${name}' in {{${prefix}${name}}}`);
+      } else {
+        stack.push({
+          children: [],
+          closer: {
+            kind: "boolean",
+            conditional: name,
+            negated: prefix === "^"
+          }
+        });
       }
-      stack.push({
-        children: [],
-        closer: { conditional: name, negated: prefix === "^" }
-      });
     } else if (prefix === "/") {
       const frame = stack.pop();
       if (!frame || !frame.closer) {
@@ -304499,12 +304539,23 @@ function parseBlocks(template) {
       if (!parent) {
         throw unsupportedSyntaxError("block stack underflow while closing tag");
       }
-      parent.children.push({
-        kind: "block",
-        conditional: frame.closer.conditional,
-        negated: frame.closer.negated,
-        children: frame.children
-      });
+      if (frame.closer.kind === "tag") {
+        parent.children.push({
+          kind: "tagBlock",
+          conditional: frame.closer.conditional,
+          negated: frame.closer.negated,
+          variable: frame.closer.variable,
+          comparisons: frame.closer.comparisons,
+          children: frame.children
+        });
+      } else {
+        parent.children.push({
+          kind: "block",
+          conditional: frame.closer.conditional,
+          negated: frame.closer.negated,
+          children: frame.children
+        });
+      }
     } else {
       const top = stack[stack.length - 1];
       if (top) {
@@ -304529,20 +304580,46 @@ function parseBlocks(template) {
   }
   return root.children;
 }
-function renderBlocks(tokens, conditionals, resolved) {
+function evaluateTagConditional(name, variable, comparisons, variables) {
+  const resolvedValue = lookupVariable(variable, variables);
+  const value = resolvedValue ?? "";
+  if (name === "is_exact_match") {
+    return comparisons.some((comparison) => value === comparison);
+  }
+  return comparisons.some((comparison) => value.includes(comparison));
+}
+function renderBlocks(tokens, sink) {
   let out = "";
   for (const token of tokens) {
     if (token.kind === "literal") {
       out += token.text;
       continue;
     }
-    const flag = conditionals[token.conditional] ?? false;
-    resolved[token.conditional] = flag;
-    const include = token.negated ? !flag : flag;
+    let include;
+    if (token.kind === "tagBlock") {
+      const matched = evaluateTagConditional(
+        token.conditional,
+        token.variable,
+        token.comparisons,
+        sink.variables
+      );
+      sink.tagResolved.push({
+        name: token.conditional,
+        negated: token.negated,
+        variable: token.variable,
+        comparisons: token.comparisons,
+        matched
+      });
+      include = token.negated ? !matched : matched;
+    } else {
+      const flag = sink.conditionals[token.conditional] ?? false;
+      sink.resolved[token.conditional] = flag;
+      include = token.negated ? !flag : flag;
+    }
     if (include) {
-      out += renderBlocks(token.children, conditionals, resolved);
+      out += renderBlocks(token.children, sink);
     } else {
-      renderBlocks(token.children, conditionals, resolved);
+      renderBlocks(token.children, sink);
     }
   }
   return out;
@@ -304572,13 +304649,20 @@ function renderMonitorTemplate(template, context) {
   const conditionals = context.conditionals ?? {};
   const tree = parseBlocks(template);
   const conditionalsResolved = {};
-  const afterConditionals = renderBlocks(tree, conditionals, conditionalsResolved);
+  const tagConditionalsResolved = [];
+  const afterConditionals = renderBlocks(tree, {
+    conditionals,
+    variables,
+    resolved: conditionalsResolved,
+    tagResolved: tagConditionalsResolved
+  });
   const { rendered, used, missing } = substituteVariables(afterConditionals, variables);
   return {
     rendered,
     variablesUsed: used,
     variablesMissing: missing,
-    conditionalsResolved
+    conditionalsResolved,
+    tagConditionalsResolved
   };
 }
 
@@ -305322,6 +305406,10 @@ preview: Render a Datadog monitor message template against a context (read-only
   - Inputs: either inline 'message' OR 'monitor_id' (or existing 'id'); plus optional 'context' { variables, conditionals }.
   - Supported syntax: {{variable.name}} substitution and conditional blocks {{#name}}...{{/name}} / {{^name}}...{{/name}}
     where name is one of: ${SUPPORTED_CONDITIONALS.join(", ")}.
+  - Also supports Datadog tag conditionals {{#is_match "tag" "val" ...}} (substring) and
+    {{#is_exact_match "tag" "val" ...}} (exact), plus their {{^...}} negations. The tag is resolved
+    against context.variables; multiple comparison values are OR'd; comparison is case-sensitive.
+    Evaluated tag conditionals are reported in 'tagConditionalsResolved'.
   - Missing variables render as {{undefined:name}} markers and are reported in 'variablesMissing'.
   - Loops ({{#each ...}}) and partials ({{> ...}}) return EUNSUPPORTED_TEMPLATE_SYNTAX.
   - Allowed under --read-only (no mutation; at most a getMonitor load).