terraconstructs 0.0.8

package/lib/aws/cloudwatch/private/rendering.js

@@ -0,0 +1,181 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/rendering.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricSet = exports.allMetricsGraphJson = void 0;
+const drop_empty_object_at_the_end_of_an_array_token_1 = require("./drop-empty-object-at-the-end-of-an-array-token");
+const env_tokens_1 = require("./env-tokens");
+const metric_util_1 = require("./metric-util");
+const object_1 = require("./object");
+/**
+ * Return the JSON structure which represents these metrics in a graph.
+ *
+ * Depending on the metric type (stat or expression), one `Metric` object
+ * can render to multiple time series.
+ *
+ * - Top-level metrics will be rendered visibly, additionally added metrics will
+ *   be rendered invisibly.
+ * - IDs used in math expressions need to be either globally unique, or refer to the same
+ *   metric object.
+ *
+ * This will be called by GraphWidget, no need for clients to call this.
+ */
+function allMetricsGraphJson(left, right) {
+    // Add metrics to a set which will automatically expand them recursively,
+    // making sure to retain conflicting the visible one on conflicting metrics objects.
+    const mset = new MetricSet();
+    mset.addTopLevel("left", ...left);
+    mset.addTopLevel("right", ...right);
+    // Render all metrics from the set.
+    return mset.entries.map((entry) => new drop_empty_object_at_the_end_of_an_array_token_1.DropEmptyObjectAtTheEndOfAnArray(metricGraphJson(entry.metric, entry.tag, entry.id)));
+}
+exports.allMetricsGraphJson = allMetricsGraphJson;
+function metricGraphJson(metric, yAxis, id) {
+    const config = metric.toMetricConfig();
+    const ret = [];
+    const options = { ...config.renderingProperties };
+    (0, metric_util_1.dispatchMetric)(metric, {
+        withStat(stat) {
+            ret.push(stat.namespace, stat.metricName);
+            // Dimensions
+            for (const [dimName, dimValue] of Object.entries(stat.dimensions || {})) {
+                ret.push(dimName, dimValue);
+            }
+            // Metric attributes that are rendered to graph options
+            if (stat.account) {
+                options.accountId = (0, env_tokens_1.accountIfDifferentFromStack)(stat.account);
+            }
+            if (stat.region) {
+                options.region = (0, env_tokens_1.regionIfDifferentFromStack)(stat.region);
+            }
+            if (stat.period && stat.period.toSeconds() !== 300) {
+                options.period = stat.period.toSeconds();
+            }
+            if (stat.statistic && stat.statistic !== "Average") {
+                options.stat = stat.statistic;
+            }
+        },
+        withExpression(expr) {
+            options.expression = expr.expression;
+            if (expr.searchAccount) {
+                options.accountId = (0, env_tokens_1.accountIfDifferentFromStack)(expr.searchAccount);
+            }
+            if (expr.searchRegion) {
+                options.region = (0, env_tokens_1.regionIfDifferentFromStack)(expr.searchRegion);
+            }
+            if (expr.period && expr.period !== 300) {
+                options.period = expr.period;
+            }
+        },
+    });
+    // Options
+    if (!yAxis) {
+        options.visible = false;
+    }
+    if (yAxis !== "left") {
+        options.yAxis = yAxis;
+    }
+    if (id) {
+        options.id = id;
+    }
+    if (options.visible !== false && options.expression && !options.label) {
+        // Label may be '' or undefined.
+        //
+        // If undefined, we'll render the expression as the label, to suppress
+        // the default behavior of CW where it would render the metric
+        // id as label, which we (inelegantly) generate to be something like "metric_alias0".
+        //
+        // For array expressions (returning more than 1 TS) users may sometimes want to
+        // suppress the label completely. For those cases, we'll accept the empty string,
+        // and not render a label at all.
+        options.label = options.label === "" ? undefined : metric.toString();
+    }
+    const renderedOpts = (0, object_1.dropUndefined)(options);
+    if (Object.keys(renderedOpts).length !== 0) {
+        ret.push(renderedOpts);
+    }
+    return ret;
+}
+/**
+ * Contain a set of metrics, expanding math expressions
+ *
+ * "Primary" metrics (added via a top-level call) can be tagged with an additional value.
+ */
+class MetricSet {
+    constructor() {
+        this.metrics = new Array();
+        this.metricById = new Map();
+        this.metricByKey = new Map();
+    }
+    /**
+     * Add the given set of metrics to this set
+     */
+    addTopLevel(tag, ...metrics) {
+        for (const metric of metrics) {
+            this.addOne(metric, tag);
+        }
+    }
+    /**
+     * Access all the accumulated timeseries entries
+     */
+    get entries() {
+        return this.metrics;
+    }
+    /**
+     * Add a metric into the set
+     *
+     * The id may not be the same as a previous metric added, unless it's the same metric.
+     *
+     * It can be made visible, in which case the new "metric" object replaces the old
+     * one (and the new ones "renderingPropertieS" will be honored instead of the old
+     * one's).
+     */
+    addOne(metric, tag, id) {
+        const key = (0, metric_util_1.metricKey)(metric);
+        let existingEntry;
+        // Try lookup existing by id if we have one
+        if (id) {
+            existingEntry = this.metricById.get(id);
+            if (existingEntry && (0, metric_util_1.metricKey)(existingEntry.metric) !== key) {
+                throw new Error(`Cannot have two different metrics share the same id ('${id}') in one Alarm or Graph. Rename one of them.`);
+            }
+        }
+        if (!existingEntry) {
+            // Try lookup by metric if we didn't find one by id
+            existingEntry = this.metricByKey.get(key);
+            // If the one we found already has an id, it must be different from the id
+            // we're trying to add and we want to add a new metric. Pretend we didn't
+            // find one.
+            if (existingEntry?.id && id) {
+                existingEntry = undefined;
+            }
+        }
+        // Create a new entry if we didn't find one so far
+        let entry;
+        if (existingEntry) {
+            entry = existingEntry;
+        }
+        else {
+            entry = { metric };
+            this.metrics.push(entry);
+            this.metricByKey.set(key, entry);
+        }
+        // If it didn't have an id but now we do, add one
+        if (!entry.id && id) {
+            entry.id = id;
+            this.metricById.set(id, entry);
+        }
+        // If it didn't have a tag but now we do, add one
+        if (!entry.tag && tag) {
+            entry.tag = tag;
+        }
+        // Recurse and add children
+        const conf = metric.toMetricConfig();
+        if (conf.mathExpression) {
+            for (const [subId, subMetric] of Object.entries(conf.mathExpression.usingMetrics)) {
+                this.addOne(subMetric, undefined, subId);
+            }
+        }
+    }
+}
+exports.MetricSet = MetricSet;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rendering.js","sourceRoot":"","sources":["../../../../src/aws/cloudwatch/private/rendering.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/rendering.ts\n\nimport { DropEmptyObjectAtTheEndOfAnArray } from \"./drop-empty-object-at-the-end-of-an-array-token\";\nimport {\n  accountIfDifferentFromStack,\n  regionIfDifferentFromStack,\n} from \"./env-tokens\";\nimport { dispatchMetric, metricKey } from \"./metric-util\";\nimport { dropUndefined } from \"./object\";\nimport { IMetric } from \"../metric-types\";\n\n/**\n * Return the JSON structure which represents these metrics in a graph.\n *\n * Depending on the metric type (stat or expression), one `Metric` object\n * can render to multiple time series.\n *\n * - Top-level metrics will be rendered visibly, additionally added metrics will\n *   be rendered invisibly.\n * - IDs used in math expressions need to be either globally unique, or refer to the same\n *   metric object.\n *\n * This will be called by GraphWidget, no need for clients to call this.\n */\nexport function allMetricsGraphJson(left: IMetric[], right: IMetric[]): any[] {\n  // Add metrics to a set which will automatically expand them recursively,\n  // making sure to retain conflicting the visible one on conflicting metrics objects.\n  const mset = new MetricSet<string>();\n  mset.addTopLevel(\"left\", ...left);\n  mset.addTopLevel(\"right\", ...right);\n\n  // Render all metrics from the set.\n  return mset.entries.map(\n    (entry) =>\n      new DropEmptyObjectAtTheEndOfAnArray(\n        metricGraphJson(entry.metric, entry.tag, entry.id),\n      ),\n  );\n}\n\nfunction metricGraphJson(metric: IMetric, yAxis?: string, id?: string) {\n  const config = metric.toMetricConfig();\n\n  const ret: any[] = [];\n  const options: any = { ...config.renderingProperties };\n\n  dispatchMetric(metric, {\n    withStat(stat) {\n      ret.push(stat.namespace, stat.metricName);\n\n      // Dimensions\n      for (const [dimName, dimValue] of Object.entries(stat.dimensions || {})) {\n        ret.push(dimName, dimValue);\n      }\n\n      // Metric attributes that are rendered to graph options\n      if (stat.account) {\n        options.accountId = accountIfDifferentFromStack(stat.account);\n      }\n      if (stat.region) {\n        options.region = regionIfDifferentFromStack(stat.region);\n      }\n      if (stat.period && stat.period.toSeconds() !== 300) {\n        options.period = stat.period.toSeconds();\n      }\n      if (stat.statistic && stat.statistic !== \"Average\") {\n        options.stat = stat.statistic;\n      }\n    },\n\n    withExpression(expr) {\n      options.expression = expr.expression;\n      if (expr.searchAccount) {\n        options.accountId = accountIfDifferentFromStack(expr.searchAccount);\n      }\n      if (expr.searchRegion) {\n        options.region = regionIfDifferentFromStack(expr.searchRegion);\n      }\n      if (expr.period && expr.period !== 300) {\n        options.period = expr.period;\n      }\n    },\n  });\n\n  // Options\n  if (!yAxis) {\n    options.visible = false;\n  }\n  if (yAxis !== \"left\") {\n    options.yAxis = yAxis;\n  }\n  if (id) {\n    options.id = id;\n  }\n\n  if (options.visible !== false && options.expression && !options.label) {\n    // Label may be '' or undefined.\n    //\n    // If undefined, we'll render the expression as the label, to suppress\n    // the default behavior of CW where it would render the metric\n    // id as label, which we (inelegantly) generate to be something like \"metric_alias0\".\n    //\n    // For array expressions (returning more than 1 TS) users may sometimes want to\n    // suppress the label completely. For those cases, we'll accept the empty string,\n    // and not render a label at all.\n    options.label = options.label === \"\" ? undefined : metric.toString();\n  }\n\n  const renderedOpts = dropUndefined(options);\n\n  if (Object.keys(renderedOpts).length !== 0) {\n    ret.push(renderedOpts);\n  }\n  return ret;\n}\n\n/**\n * A single metric in a MetricSet\n */\nexport interface MetricEntry<A> {\n  /**\n   * The metric object\n   */\n  readonly metric: IMetric;\n\n  /**\n   * The tag, added if the object is a primary metric\n   */\n  tag?: A;\n\n  /**\n   * ID for this metric object\n   */\n  id?: string;\n}\n\n/**\n * Contain a set of metrics, expanding math expressions\n *\n * \"Primary\" metrics (added via a top-level call) can be tagged with an additional value.\n */\nexport class MetricSet<A> {\n  private readonly metrics = new Array<MetricEntry<A>>();\n  private readonly metricById = new Map<string, MetricEntry<A>>();\n  private readonly metricByKey = new Map<string, MetricEntry<A>>();\n\n  /**\n   * Add the given set of metrics to this set\n   */\n  public addTopLevel(tag: A, ...metrics: IMetric[]) {\n    for (const metric of metrics) {\n      this.addOne(metric, tag);\n    }\n  }\n\n  /**\n   * Access all the accumulated timeseries entries\n   */\n  public get entries(): ReadonlyArray<MetricEntry<A>> {\n    return this.metrics;\n  }\n\n  /**\n   * Add a metric into the set\n   *\n   * The id may not be the same as a previous metric added, unless it's the same metric.\n   *\n   * It can be made visible, in which case the new \"metric\" object replaces the old\n   * one (and the new ones \"renderingPropertieS\" will be honored instead of the old\n   * one's).\n   */\n  private addOne(metric: IMetric, tag?: A, id?: string) {\n    const key = metricKey(metric);\n\n    let existingEntry: MetricEntry<A> | undefined;\n\n    // Try lookup existing by id if we have one\n    if (id) {\n      existingEntry = this.metricById.get(id);\n      if (existingEntry && metricKey(existingEntry.metric) !== key) {\n        throw new Error(\n          `Cannot have two different metrics share the same id ('${id}') in one Alarm or Graph. Rename one of them.`,\n        );\n      }\n    }\n\n    if (!existingEntry) {\n      // Try lookup by metric if we didn't find one by id\n      existingEntry = this.metricByKey.get(key);\n\n      // If the one we found already has an id, it must be different from the id\n      // we're trying to add and we want to add a new metric. Pretend we didn't\n      // find one.\n      if (existingEntry?.id && id) {\n        existingEntry = undefined;\n      }\n    }\n\n    // Create a new entry if we didn't find one so far\n    let entry;\n    if (existingEntry) {\n      entry = existingEntry;\n    } else {\n      entry = { metric };\n      this.metrics.push(entry);\n      this.metricByKey.set(key, entry);\n    }\n\n    // If it didn't have an id but now we do, add one\n    if (!entry.id && id) {\n      entry.id = id;\n      this.metricById.set(id, entry);\n    }\n\n    // If it didn't have a tag but now we do, add one\n    if (!entry.tag && tag) {\n      entry.tag = tag;\n    }\n\n    // Recurse and add children\n    const conf = metric.toMetricConfig();\n    if (conf.mathExpression) {\n      for (const [subId, subMetric] of Object.entries(\n        conf.mathExpression.usingMetrics,\n      )) {\n        this.addOne(subMetric, undefined, subId);\n      }\n    }\n  }\n}\n"]}

package/lib/aws/cloudwatch/private/statistic.d.ts

@@ -0,0 +1,51 @@
+export interface SimpleStatistic {
+    type: "simple";
+    statistic: string;
+}
+export interface GenericStatistic {
+    type: "generic";
+    statistic: string;
+}
+export interface ParseableStatistic {
+    statPrefix: string;
+    statName: string;
+    rawStatistic: string;
+}
+export interface SingleStatistic extends ParseableStatistic {
+    type: "single";
+    value: number;
+}
+export interface PairStatistic extends ParseableStatistic {
+    type: "pair";
+    isPercent: boolean;
+    lower?: number;
+    upper?: number;
+    canBeSingleStat: boolean;
+    asSingleStatStr?: string;
+}
+export interface PercentileStatistic extends SingleStatistic {
+    statName: "percentile";
+}
+export interface PercentileRankStatistic extends PairStatistic {
+    statName: "percentileRank";
+}
+export interface TrimmedMeanStatistic extends PairStatistic {
+    statName: "trimmedMean";
+}
+export interface WinsorizedMeanStatistic extends PairStatistic {
+    statName: "winsorizedMean";
+}
+export interface TrimmedCountStatistic extends PairStatistic {
+    statName: "trimmedCount";
+}
+export interface TrimmedSumStatistic extends PairStatistic {
+    statName: "trimmedSum";
+}
+export declare function singleStatisticToString(parsed: SingleStatistic): string;
+export declare function pairStatisticToString(parsed: PairStatistic): string;
+/**
+ * Parse a statistic, returning the type of metric that was used
+ */
+export declare function parseStatistic(stat: string): SimpleStatistic | PercentileStatistic | PercentileRankStatistic | TrimmedMeanStatistic | WinsorizedMeanStatistic | TrimmedCountStatistic | TrimmedSumStatistic | GenericStatistic;
+export declare function normalizeStatistic(parsed: ReturnType<typeof parseStatistic>): string;
+export declare function normalizeRawStringStatistic(stat: string): string;

package/lib/aws/cloudwatch/private/statistic.js

@@ -0,0 +1,176 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/statistic.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRawStringStatistic = exports.normalizeStatistic = exports.parseStatistic = exports.pairStatisticToString = exports.singleStatisticToString = void 0;
+const stats_1 = require("../stats");
+function parseSingleStatistic(statistic, prefix) {
+    const prefixLower = prefix.toLowerCase();
+    // Allow `P99` uppercase
+    statistic = statistic.toLowerCase();
+    if (!statistic.startsWith(prefixLower)) {
+        return undefined;
+    }
+    // A decimal positive number regex (1, 1.2, 99.999, etc)
+    const reDecimal = "\\d+(?:\\.\\d+)?";
+    // p99.99
+    // /^p(\d+(?:\.\d+)?)$/
+    const r = new RegExp(`^${prefixLower}(${reDecimal})$`).exec(statistic);
+    if (!r) {
+        return undefined;
+    }
+    const value = parseFloat(r[1]);
+    if (value < 0 || value > 100) {
+        return undefined;
+    }
+    return {
+        type: "single",
+        rawStatistic: statistic,
+        statPrefix: prefixLower,
+        value,
+    };
+}
+/**
+ * Parse a statistic that looks like `tm( LOWER : UPPER )`.
+ */
+function parsePairStatistic(statistic, prefix) {
+    const r = new RegExp(`^${prefix}\\(([^)]+)\\)$`, "i").exec(statistic);
+    if (!r) {
+        return undefined;
+    }
+    const common = {
+        type: "pair",
+        canBeSingleStat: false,
+        rawStatistic: statistic,
+        statPrefix: prefix.toUpperCase(),
+    };
+    const [lhs, rhs] = r[1].split(":");
+    if (rhs === undefined) {
+        // Doesn't have 2 parts
+        return undefined;
+    }
+    const parseNumberAndPercent = (x) => {
+        x = x.trim();
+        if (!x) {
+            return [undefined, false];
+        }
+        const value = parseFloat(x.replace(/%$/, ""));
+        const percent = x.endsWith("%");
+        if (isNaN(value) || value < 0 || (percent && value > 100)) {
+            return ["fail", false];
+        }
+        return [value, percent];
+    };
+    const [lower, lhsPercent] = parseNumberAndPercent(lhs);
+    const [upper, rhsPercent] = parseNumberAndPercent(rhs);
+    if (lower === "fail" ||
+        upper === "fail" ||
+        (lower === undefined && upper === undefined)) {
+        return undefined;
+    }
+    if (lower !== undefined && upper !== undefined && lhsPercent !== rhsPercent) {
+        // If one value is a percentage, the other one must be too
+        return undefined;
+    }
+    const isPercent = lhsPercent || rhsPercent;
+    const canBeSingleStat = lower === undefined && isPercent;
+    const asSingleStatStr = canBeSingleStat
+        ? `${prefix.toLowerCase()}${upper}`
+        : undefined;
+    return {
+        ...common,
+        lower,
+        upper,
+        isPercent,
+        canBeSingleStat,
+        asSingleStatStr,
+    };
+}
+function singleStatisticToString(parsed) {
+    return `${parsed.statPrefix}${parsed.value}`;
+}
+exports.singleStatisticToString = singleStatisticToString;
+function pairStatisticToString(parsed) {
+    const percent = parsed.isPercent ? "%" : "";
+    const lower = parsed.lower ? `${parsed.lower}${percent}` : "";
+    const upper = parsed.upper ? `${parsed.upper}${percent}` : "";
+    return `${parsed.statPrefix}(${lower}:${upper})`;
+}
+exports.pairStatisticToString = pairStatisticToString;
+/**
+ * Parse a statistic, returning the type of metric that was used
+ */
+function parseStatistic(stat) {
+    const lowerStat = stat.toLowerCase();
+    // Simple statistics
+    const statMap = {
+        average: stats_1.Stats.AVERAGE,
+        avg: stats_1.Stats.AVERAGE,
+        minimum: stats_1.Stats.MINIMUM,
+        min: stats_1.Stats.MINIMUM,
+        maximum: stats_1.Stats.MAXIMUM,
+        max: stats_1.Stats.MAXIMUM,
+        samplecount: stats_1.Stats.SAMPLE_COUNT,
+        n: stats_1.Stats.SAMPLE_COUNT,
+        sum: stats_1.Stats.SUM,
+        iqm: stats_1.Stats.IQM,
+    };
+    if (lowerStat in statMap) {
+        return {
+            type: "simple",
+            statistic: statMap[lowerStat],
+        };
+    }
+    let m = undefined;
+    // Percentile statistics
+    m = parseSingleStatistic(stat, "p");
+    if (m)
+        return { ...m, statName: "percentile" };
+    // Percentile Rank statistics
+    m = parsePairStatistic(stat, "pr");
+    if (m)
+        return { ...m, statName: "percentileRank" };
+    // Trimmed mean statistics
+    m = parseSingleStatistic(stat, "tm") || parsePairStatistic(stat, "tm");
+    if (m)
+        return { ...m, statName: "trimmedMean" };
+    // Winsorized mean statistics
+    m = parseSingleStatistic(stat, "wm") || parsePairStatistic(stat, "wm");
+    if (m)
+        return { ...m, statName: "winsorizedMean" };
+    // Trimmed count statistics
+    m = parseSingleStatistic(stat, "tc") || parsePairStatistic(stat, "tc");
+    if (m)
+        return { ...m, statName: "trimmedCount" };
+    // Trimmed sum statistics
+    m = parseSingleStatistic(stat, "ts") || parsePairStatistic(stat, "ts");
+    if (m)
+        return { ...m, statName: "trimmedSum" };
+    return {
+        type: "generic",
+        statistic: stat,
+    };
+}
+exports.parseStatistic = parseStatistic;
+function normalizeStatistic(parsed) {
+    if (parsed.type === "simple" || parsed.type === "generic") {
+        return parsed.statistic;
+    }
+    else if (parsed.type === "single") {
+        // Avoid parsing because we might get into
+        // floating point rounding issues, return as-is but lowercase the stat prefix.
+        return parsed.rawStatistic.toLowerCase();
+    }
+    else if (parsed.type === "pair") {
+        // Avoid parsing because we might get into
+        // floating point rounding issues, return as-is but uppercase the stat prefix.
+        return parsed.rawStatistic.toUpperCase();
+    }
+    return "";
+}
+exports.normalizeStatistic = normalizeStatistic;
+function normalizeRawStringStatistic(stat) {
+    const parsed = parseStatistic(stat);
+    return normalizeStatistic(parsed);
+}
+exports.normalizeRawStringStatistic = normalizeRawStringStatistic;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"statistic.js","sourceRoot":"","sources":["../../../../src/aws/cloudwatch/private/statistic.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/statistic.ts\n\nimport { Stats } from \"../stats\";\n\nexport interface SimpleStatistic {\n  type: \"simple\";\n  statistic: string;\n}\n\nexport interface GenericStatistic {\n  type: \"generic\";\n  statistic: string;\n}\n\nexport interface ParseableStatistic {\n  statPrefix: string;\n  statName: string;\n  rawStatistic: string;\n}\n\nexport interface SingleStatistic extends ParseableStatistic {\n  type: \"single\";\n  value: number;\n}\n\nexport interface PairStatistic extends ParseableStatistic {\n  type: \"pair\";\n  isPercent: boolean;\n  lower?: number;\n  upper?: number;\n  canBeSingleStat: boolean;\n  asSingleStatStr?: string;\n}\n\nexport interface PercentileStatistic extends SingleStatistic {\n  statName: \"percentile\";\n}\n\nexport interface PercentileRankStatistic extends PairStatistic {\n  statName: \"percentileRank\";\n}\n\nexport interface TrimmedMeanStatistic extends PairStatistic {\n  statName: \"trimmedMean\";\n}\n\nexport interface WinsorizedMeanStatistic extends PairStatistic {\n  statName: \"winsorizedMean\";\n}\n\nexport interface TrimmedCountStatistic extends PairStatistic {\n  statName: \"trimmedCount\";\n}\n\nexport interface TrimmedSumStatistic extends PairStatistic {\n  statName: \"trimmedSum\";\n}\n\nfunction parseSingleStatistic(\n  statistic: string,\n  prefix: string,\n): Omit<SingleStatistic, \"statName\"> | undefined {\n  const prefixLower = prefix.toLowerCase();\n\n  // Allow `P99` uppercase\n  statistic = statistic.toLowerCase();\n\n  if (!statistic.startsWith(prefixLower)) {\n    return undefined;\n  }\n\n  // A decimal positive number regex (1, 1.2, 99.999, etc)\n  const reDecimal = \"\\\\d+(?:\\\\.\\\\d+)?\";\n\n  // p99.99\n  // /^p(\\d+(?:\\.\\d+)?)$/\n  const r = new RegExp(`^${prefixLower}(${reDecimal})$`).exec(statistic);\n  if (!r) {\n    return undefined;\n  }\n\n  const value = parseFloat(r[1]);\n  if (value < 0 || value > 100) {\n    return undefined;\n  }\n  return {\n    type: \"single\",\n    rawStatistic: statistic,\n    statPrefix: prefixLower,\n    value,\n  };\n}\n\n/**\n * Parse a statistic that looks like `tm( LOWER : UPPER )`.\n */\nfunction parsePairStatistic(\n  statistic: string,\n  prefix: string,\n): Omit<PairStatistic, \"statName\"> | undefined {\n  const r = new RegExp(`^${prefix}\\\\(([^)]+)\\\\)$`, \"i\").exec(statistic);\n  if (!r) {\n    return undefined;\n  }\n\n  const common: Omit<PairStatistic, \"statName\" | \"isPercent\"> = {\n    type: \"pair\",\n    canBeSingleStat: false,\n    rawStatistic: statistic,\n    statPrefix: prefix.toUpperCase(),\n  };\n\n  const [lhs, rhs] = r[1].split(\":\");\n  if (rhs === undefined) {\n    // Doesn't have 2 parts\n    return undefined;\n  }\n\n  const parseNumberAndPercent = (\n    x: string,\n  ): [number | undefined | \"fail\", boolean] => {\n    x = x.trim();\n    if (!x) {\n      return [undefined, false];\n    }\n    const value = parseFloat(x.replace(/%$/, \"\"));\n    const percent = x.endsWith(\"%\");\n    if (isNaN(value) || value < 0 || (percent && value > 100)) {\n      return [\"fail\", false];\n    }\n    return [value, percent];\n  };\n\n  const [lower, lhsPercent] = parseNumberAndPercent(lhs);\n  const [upper, rhsPercent] = parseNumberAndPercent(rhs);\n  if (\n    lower === \"fail\" ||\n    upper === \"fail\" ||\n    (lower === undefined && upper === undefined)\n  ) {\n    return undefined;\n  }\n\n  if (lower !== undefined && upper !== undefined && lhsPercent !== rhsPercent) {\n    // If one value is a percentage, the other one must be too\n    return undefined;\n  }\n\n  const isPercent = lhsPercent || rhsPercent;\n  const canBeSingleStat = lower === undefined && isPercent;\n  const asSingleStatStr = canBeSingleStat\n    ? `${prefix.toLowerCase()}${upper}`\n    : undefined;\n\n  return {\n    ...common,\n    lower,\n    upper,\n    isPercent,\n    canBeSingleStat,\n    asSingleStatStr,\n  };\n}\n\nexport function singleStatisticToString(parsed: SingleStatistic): string {\n  return `${parsed.statPrefix}${parsed.value}`;\n}\n\nexport function pairStatisticToString(parsed: PairStatistic): string {\n  const percent = parsed.isPercent ? \"%\" : \"\";\n  const lower = parsed.lower ? `${parsed.lower}${percent}` : \"\";\n  const upper = parsed.upper ? `${parsed.upper}${percent}` : \"\";\n  return `${parsed.statPrefix}(${lower}:${upper})`;\n}\n\n/**\n * Parse a statistic, returning the type of metric that was used\n */\nexport function parseStatistic(\n  stat: string,\n):\n  | SimpleStatistic\n  | PercentileStatistic\n  | PercentileRankStatistic\n  | TrimmedMeanStatistic\n  | WinsorizedMeanStatistic\n  | TrimmedCountStatistic\n  | TrimmedSumStatistic\n  | GenericStatistic {\n  const lowerStat = stat.toLowerCase();\n\n  // Simple statistics\n  const statMap: { [k: string]: string } = {\n    average: Stats.AVERAGE,\n    avg: Stats.AVERAGE,\n    minimum: Stats.MINIMUM,\n    min: Stats.MINIMUM,\n    maximum: Stats.MAXIMUM,\n    max: Stats.MAXIMUM,\n    samplecount: Stats.SAMPLE_COUNT,\n    n: Stats.SAMPLE_COUNT,\n    sum: Stats.SUM,\n    iqm: Stats.IQM,\n  };\n\n  if (lowerStat in statMap) {\n    return {\n      type: \"simple\",\n      statistic: statMap[lowerStat],\n    } as SimpleStatistic;\n  }\n\n  let m:\n    | ReturnType<typeof parseSingleStatistic>\n    | ReturnType<typeof parsePairStatistic> = undefined;\n\n  // Percentile statistics\n  m = parseSingleStatistic(stat, \"p\");\n  if (m) return { ...m, statName: \"percentile\" } as PercentileStatistic;\n\n  // Percentile Rank statistics\n  m = parsePairStatistic(stat, \"pr\");\n  if (m) return { ...m, statName: \"percentileRank\" } as PercentileRankStatistic;\n\n  // Trimmed mean statistics\n  m = parseSingleStatistic(stat, \"tm\") || parsePairStatistic(stat, \"tm\");\n  if (m) return { ...m, statName: \"trimmedMean\" } as TrimmedMeanStatistic;\n\n  // Winsorized mean statistics\n  m = parseSingleStatistic(stat, \"wm\") || parsePairStatistic(stat, \"wm\");\n  if (m) return { ...m, statName: \"winsorizedMean\" } as WinsorizedMeanStatistic;\n\n  // Trimmed count statistics\n  m = parseSingleStatistic(stat, \"tc\") || parsePairStatistic(stat, \"tc\");\n  if (m) return { ...m, statName: \"trimmedCount\" } as TrimmedCountStatistic;\n\n  // Trimmed sum statistics\n  m = parseSingleStatistic(stat, \"ts\") || parsePairStatistic(stat, \"ts\");\n  if (m) return { ...m, statName: \"trimmedSum\" } as TrimmedSumStatistic;\n\n  return {\n    type: \"generic\",\n    statistic: stat,\n  } as GenericStatistic;\n}\n\nexport function normalizeStatistic(\n  parsed: ReturnType<typeof parseStatistic>,\n): string {\n  if (parsed.type === \"simple\" || parsed.type === \"generic\") {\n    return parsed.statistic;\n  } else if (parsed.type === \"single\") {\n    // Avoid parsing because we might get into\n    // floating point rounding issues, return as-is but lowercase the stat prefix.\n    return parsed.rawStatistic.toLowerCase();\n  } else if (parsed.type === \"pair\") {\n    // Avoid parsing because we might get into\n    // floating point rounding issues, return as-is but uppercase the stat prefix.\n    return parsed.rawStatistic.toUpperCase();\n  }\n\n  return \"\";\n}\n\nexport function normalizeRawStringStatistic(stat: string): string {\n  const parsed = parseStatistic(stat);\n  return normalizeStatistic(parsed);\n}\n"]}

package/lib/aws/cloudwatch/query-definition.d.ts

@@ -0,0 +1,150 @@
+import { cloudwatchQueryDefinition } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { ILogGroup } from "./log-group";
+/**
+ * Properties for a QueryString
+ */
+export interface QueryStringProps {
+    /**
+     * Retrieves the specified fields from log events for display.
+     *
+     * @default - no fields in QueryString
+     */
+    readonly fields?: string[];
+    /**
+     * A single statement for parsing data from a log field and creating ephemeral fields that can
+     * be processed further in the query.
+     *
+     * @deprecated Use `parseStatements` instead
+     * @default - no parse in QueryString
+     */
+    readonly parse?: string;
+    /**
+     * An array of one or more statements for parsing data from a log field and creating ephemeral
+     * fields that can be processed further in the query. Each provided statement generates a separate
+     * parse line in the query string.
+     *
+     * Note: If provided, this property overrides any value provided for the `parse` property.
+     *
+     * @default - no parse in QueryString
+     */
+    readonly parseStatements?: string[];
+    /**
+     * A single statement for filtering the results of a query based on a boolean expression.
+     *
+     * @deprecated Use `filterStatements` instead
+     * @default - no filter in QueryString
+     */
+    readonly filter?: string;
+    /**
+     * An array of one or more statements for filtering the results of a query based on a boolean
+     * expression. Each provided statement generates a separate filter line in the query string.
+     *
+     * Note: If provided, this property overrides any value provided for the `filter` property.
+     *
+     * @default - no filter in QueryString
+     */
+    readonly filterStatements?: string[];
+    /**
+     * Uses log field values to calculate aggregate statistics.
+     *
+     * @default - no stats in QueryString
+     */
+    readonly stats?: string;
+    /**
+     * Sorts the retrieved log events.
+     *
+     * @default - no sort in QueryString
+     */
+    readonly sort?: string;
+    /**
+     * Specifies the number of log events returned by the query.
+     *
+     * @default - no limit in QueryString
+     */
+    readonly limit?: Number;
+    /**
+     * Specifies which fields to display in the query results.
+     *
+     * @default - no display in QueryString
+     */
+    readonly display?: string;
+}
+/**
+ * Define a QueryString
+ */
+export declare class QueryString {
+    private readonly fields?;
+    private readonly parse;
+    private readonly filter;
+    private readonly stats?;
+    private readonly sort?;
+    private readonly limit?;
+    private readonly display?;
+    constructor(props?: QueryStringProps);
+    /**
+     * String representation of this QueryString.
+     */
+    toString(): string;
+    /**
+     * Build an array of query lines given a command and statement(s).
+     *
+     * @param command a query command
+     * @param statements one or more query statements for the specified command, or undefined
+     * @returns an array of the query string lines generated from the provided command and statements
+     */
+    private buildQueryLines;
+    /**
+     * Build a single query line given a command and statement.
+     *
+     * @param command a query command
+     * @param statement a single query statement
+     * @returns a single query string line generated from the provided command and statement
+     */
+    private buildQueryLine;
+}
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface QueryDefinitionOutputs {
+    /**
+     * The query definition ID.
+     * @attribute
+     */
+    readonly queryDefinitionId: string;
+}
+/**
+ * Properties for a QueryDefinition
+ */
+export interface QueryDefinitionProps extends AwsConstructProps {
+    /**
+     * Name of the query definition.
+     */
+    readonly queryDefinitionName: string;
+    /**
+     * The query string to use for this query definition.
+     */
+    readonly queryString: QueryString;
+    /**
+     * Specify certain log groups for the query definition.
+     *
+     * @default - no specified log groups
+     */
+    readonly logGroups?: ILogGroup[];
+}
+/**
+ * Define a query definition for CloudWatch Logs Insights
+ */
+export declare class QueryDefinition extends AwsConstructBase {
+    /**
+     * The ID of the query definition.
+     *
+     * @attribute
+     */
+    readonly queryDefinitionId: string;
+    get queryDefinitionOutputs(): QueryDefinitionOutputs;
+    get outputs(): Record<string, any>;
+    readonly resource: cloudwatchQueryDefinition.CloudwatchQueryDefinition;
+    constructor(scope: Construct, id: string, props: QueryDefinitionProps);
+}