terraconstructs 0.0.8

package/lib/aws/cloudwatch/query-definition.js

@@ -0,0 +1,114 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryDefinition = exports.QueryString = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-logs/lib/query-definition.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * Define a QueryString
+ */
+class QueryString {
+    constructor(props = {}) {
+        this.fields = props.fields;
+        this.stats = props.stats;
+        this.sort = props.sort;
+        this.limit = props.limit;
+        this.display = props.display;
+        // Determine parsing by either the parseStatements or parse properties, or default to empty array
+        if (props.parseStatements) {
+            this.parse = props.parseStatements;
+        }
+        else if (props.parse) {
+            this.parse = [props.parse];
+        }
+        else {
+            this.parse = [];
+        }
+        // Determine filtering by either the filterStatements or filter properties, or default to empty array
+        if (props.filterStatements) {
+            this.filter = props.filterStatements;
+        }
+        else if (props.filter) {
+            this.filter = [props.filter];
+        }
+        else {
+            this.filter = [];
+        }
+    }
+    /**
+     * String representation of this QueryString.
+     */
+    toString() {
+        return [
+            this.buildQueryLine("fields", this.fields?.join(", ")),
+            ...this.buildQueryLines("parse", this.parse),
+            ...this.buildQueryLines("filter", this.filter),
+            this.buildQueryLine("stats", this.stats),
+            this.buildQueryLine("sort", this.sort),
+            this.buildQueryLine("limit", this.limit?.toString()),
+            this.buildQueryLine("display", this.display),
+        ]
+            .filter((queryLine) => queryLine !== undefined && queryLine.length > 0)
+            .join("\n| ");
+    }
+    /**
+     * 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
+     */
+    buildQueryLines(command, statements) {
+        if (statements === undefined) {
+            return [];
+        }
+        return statements.map((statement) => this.buildQueryLine(command, statement));
+    }
+    /**
+     * 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
+     */
+    buildQueryLine(command, statement) {
+        return statement ? `${command} ${statement}` : "";
+    }
+}
+exports.QueryString = QueryString;
+_a = JSII_RTTI_SYMBOL_1;
+QueryString[_a] = { fqn: "terraconstructs.aws.cloudwatch.QueryString", version: "0.0.8" };
+/**
+ * Define a query definition for CloudWatch Logs Insights
+ */
+class QueryDefinition extends aws_construct_1.AwsConstructBase {
+    get queryDefinitionOutputs() {
+        return {
+            queryDefinitionId: this.queryDefinitionId,
+        };
+    }
+    get outputs() {
+        return this.queryDefinitionOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const name = props.queryDefinitionName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        this.resource = new provider_aws_1.cloudwatchQueryDefinition.CloudwatchQueryDefinition(this, "Resource", {
+            name,
+            queryString: props.queryString.toString(),
+            logGroupNames: typeof props.logGroups === "undefined"
+                ? []
+                : props.logGroups.flatMap((logGroup) => logGroup.logGroupName),
+        });
+        this.queryDefinitionId = this.resource.queryDefinitionId;
+    }
+}
+exports.QueryDefinition = QueryDefinition;
+_b = JSII_RTTI_SYMBOL_1;
+QueryDefinition[_b] = { fqn: "terraconstructs.aws.cloudwatch.QueryDefinition", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-definition.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/query-definition.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-logs/lib/query-definition.ts\n\nimport { cloudwatchQueryDefinition } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { ILogGroup } from \"./log-group\";\n/**\n * Properties for a QueryString\n */\nexport interface QueryStringProps {\n  /**\n   * Retrieves the specified fields from log events for display.\n   *\n   * @default - no fields in QueryString\n   */\n  readonly fields?: string[];\n\n  /**\n   * A single statement for parsing data from a log field and creating ephemeral fields that can\n   * be processed further in the query.\n   *\n   * @deprecated Use `parseStatements` instead\n   * @default - no parse in QueryString\n   */\n  readonly parse?: string;\n\n  /**\n   * An array of one or more statements for parsing data from a log field and creating ephemeral\n   * fields that can be processed further in the query. Each provided statement generates a separate\n   * parse line in the query string.\n   *\n   * Note: If provided, this property overrides any value provided for the `parse` property.\n   *\n   * @default - no parse in QueryString\n   */\n  readonly parseStatements?: string[];\n\n  /**\n   * A single statement for filtering the results of a query based on a boolean expression.\n   *\n   * @deprecated Use `filterStatements` instead\n   * @default - no filter in QueryString\n   */\n  readonly filter?: string;\n\n  /**\n   * An array of one or more statements for filtering the results of a query based on a boolean\n   * expression. Each provided statement generates a separate filter line in the query string.\n   *\n   * Note: If provided, this property overrides any value provided for the `filter` property.\n   *\n   * @default - no filter in QueryString\n   */\n  readonly filterStatements?: string[];\n\n  /**\n   * Uses log field values to calculate aggregate statistics.\n   *\n   * @default - no stats in QueryString\n   */\n  readonly stats?: string;\n\n  /**\n   * Sorts the retrieved log events.\n   *\n   * @default - no sort in QueryString\n   */\n  readonly sort?: string;\n\n  /**\n   * Specifies the number of log events returned by the query.\n   *\n   * @default - no limit in QueryString\n   */\n  readonly limit?: Number;\n\n  /**\n   * Specifies which fields to display in the query results.\n   *\n   * @default - no display in QueryString\n   */\n  readonly display?: string;\n}\n\n/**\n * Define a QueryString\n */\nexport class QueryString {\n  private readonly fields?: string[];\n  private readonly parse: string[];\n  private readonly filter: string[];\n  private readonly stats?: string;\n  private readonly sort?: string;\n  private readonly limit?: Number;\n  private readonly display?: string;\n\n  constructor(props: QueryStringProps = {}) {\n    this.fields = props.fields;\n    this.stats = props.stats;\n    this.sort = props.sort;\n    this.limit = props.limit;\n    this.display = props.display;\n\n    // Determine parsing by either the parseStatements or parse properties, or default to empty array\n    if (props.parseStatements) {\n      this.parse = props.parseStatements;\n    } else if (props.parse) {\n      this.parse = [props.parse];\n    } else {\n      this.parse = [];\n    }\n\n    // Determine filtering by either the filterStatements or filter properties, or default to empty array\n    if (props.filterStatements) {\n      this.filter = props.filterStatements;\n    } else if (props.filter) {\n      this.filter = [props.filter];\n    } else {\n      this.filter = [];\n    }\n  }\n\n  /**\n   * String representation of this QueryString.\n   */\n  public toString(): string {\n    return [\n      this.buildQueryLine(\"fields\", this.fields?.join(\", \")),\n      ...this.buildQueryLines(\"parse\", this.parse),\n      ...this.buildQueryLines(\"filter\", this.filter),\n      this.buildQueryLine(\"stats\", this.stats),\n      this.buildQueryLine(\"sort\", this.sort),\n      this.buildQueryLine(\"limit\", this.limit?.toString()),\n      this.buildQueryLine(\"display\", this.display),\n    ]\n      .filter((queryLine) => queryLine !== undefined && queryLine.length > 0)\n      .join(\"\\n| \");\n  }\n\n  /**\n   * Build an array of query lines given a command and statement(s).\n   *\n   * @param command a query command\n   * @param statements one or more query statements for the specified command, or undefined\n   * @returns an array of the query string lines generated from the provided command and statements\n   */\n  private buildQueryLines(command: string, statements?: string[]): string[] {\n    if (statements === undefined) {\n      return [];\n    }\n\n    return statements.map((statement: string): string =>\n      this.buildQueryLine(command, statement),\n    );\n  }\n\n  /**\n   * Build a single query line given a command and statement.\n   *\n   * @param command a query command\n   * @param statement a single query statement\n   * @returns a single query string line generated from the provided command and statement\n   */\n  private buildQueryLine(command: string, statement?: string): string {\n    return statement ? `${command} ${statement}` : \"\";\n  }\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface QueryDefinitionOutputs {\n  /**\n   * The query definition ID.\n   * @attribute\n   */\n  readonly queryDefinitionId: string;\n}\n\n/**\n * Properties for a QueryDefinition\n */\nexport interface QueryDefinitionProps extends AwsConstructProps {\n  /**\n   * Name of the query definition.\n   */\n  readonly queryDefinitionName: string;\n\n  /**\n   * The query string to use for this query definition.\n   */\n  readonly queryString: QueryString;\n\n  /**\n   * Specify certain log groups for the query definition.\n   *\n   * @default - no specified log groups\n   */\n  readonly logGroups?: ILogGroup[];\n}\n\n/**\n * Define a query definition for CloudWatch Logs Insights\n */\nexport class QueryDefinition extends AwsConstructBase {\n  /**\n   * The ID of the query definition.\n   *\n   * @attribute\n   */\n  public readonly queryDefinitionId: string;\n  public get queryDefinitionOutputs(): QueryDefinitionOutputs {\n    return {\n      queryDefinitionId: this.queryDefinitionId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.queryDefinitionOutputs;\n  }\n\n  public readonly resource: cloudwatchQueryDefinition.CloudwatchQueryDefinition;\n\n  constructor(scope: Construct, id: string, props: QueryDefinitionProps) {\n    super(scope, id, props);\n    const name =\n      props.queryDefinitionName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    this.resource = new cloudwatchQueryDefinition.CloudwatchQueryDefinition(\n      this,\n      \"Resource\",\n      {\n        name,\n        queryString: props.queryString.toString(),\n        logGroupNames:\n          typeof props.logGroups === \"undefined\"\n            ? []\n            : props.logGroups.flatMap((logGroup) => logGroup.logGroupName),\n      },\n    );\n\n    this.queryDefinitionId = this.resource.queryDefinitionId;\n  }\n}\n"]}

package/lib/aws/cloudwatch/stats.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Factory functions for standard statistics strings
+ */
+export declare abstract class Stats {
+    /**
+     * The count (number) of data points used for the statistical calculation.
+     */
+    static readonly SAMPLE_COUNT = "SampleCount";
+    /**
+     * The value of Sum / SampleCount during the specified period.
+     */
+    static readonly AVERAGE = "Average";
+    /**
+     * All values submitted for the matching metric added together.
+     * This statistic can be useful for determining the total volume of a metric.
+     */
+    static readonly SUM = "Sum";
+    /**
+     * The lowest value observed during the specified period.
+     * You can use this value to determine low volumes of activity for your application.
+     */
+    static readonly MINIMUM = "Minimum";
+    /**
+     * The highest value observed during the specified period.
+     * You can use this value to determine high volumes of activity for your application.
+     */
+    static readonly MAXIMUM = "Maximum";
+    /**
+     * Interquartile mean (IQM) is the trimmed mean of the interquartile range, or the middle 50% of values.
+     *
+     * It is equivalent to `trimmedMean(25, 75)`.
+     */
+    static readonly IQM = "IQM";
+    /**
+     * Percentile indicates the relative standing of a value in a dataset.
+     *
+     * Percentiles help you get a better understanding of the distribution of your metric data.
+     *
+     * For example, `p(90)` is the 90th percentile and means that 90% of the data
+     * within the period is lower than this value and 10% of the data is higher
+     * than this value.
+     */
+    static percentile(percentile: number): string;
+    /**
+     * A shorter alias for `percentile()`.
+     */
+    static p(percentile: number): string;
+    /**
+     * Trimmed mean (TM) is the mean of all values that are between two specified boundaries.
+     *
+     * Values outside of the boundaries are ignored when the mean is calculated.
+     * You define the boundaries as one or two numbers between 0 and 100, up to 10
+     * decimal places. The numbers are percentages.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in percentages,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `tm(90)` calculates the average after removing the 10% of data
+     * points with the highest values; `tm(10, 90)` calculates the average after removing the
+     * 10% with the lowest and 10% with the highest values.
+     */
+    static trimmedMean(p1: number, p2?: number): string;
+    /**
+     * A shorter alias for `trimmedMean()`.
+     */
+    static tm(p1: number, p2?: number): string;
+    /**
+     * Winsorized mean (WM) is similar to trimmed mean.
+     *
+     * However, with winsorized mean, the values that are outside the boundary are
+     * not ignored, but instead are considered to be equal to the value at the
+     * edge of the appropriate boundary.  After this normalization, the average is
+     * calculated. You define the boundaries as one or two numbers between 0 and
+     * 100, up to 10 decimal places.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in percentages,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `tm(90)` calculates the average after removing the 10% of data
+     * points with the highest values; `tm(10, 90)` calculates the average after removing the
+     * 10% with the lowest and 10% with the highest values.
+     *
+     * For example, `wm(90)` calculates the average while treating the 10% of the
+     * highest values to be equal to the value at the 90th percentile.
+     * `wm(10, 90)` calculates the average while treaing the bottom 10% and the
+     * top 10% of values to be equal to the boundary values.
+     */
+    static winsorizedMean(p1: number, p2?: number): string;
+    /**
+     * A shorter alias for `winsorizedMean()`.
+     */
+    static wm(p1: number, p2?: number): string;
+    /**
+     * Trimmed count (TC) is the number of data points in the chosen range for a trimmed mean statistic.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in percentages,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `tc(90)` returns the number of data points not including any
+     * data points that fall in the highest 10% of the values. `tc(10, 90)`
+     * returns the number of data points not including any data points that fall
+     * in the lowest 10% of the values and the highest 90% of the values.
+     */
+    static trimmedCount(p1: number, p2?: number): string;
+    /**
+     * Shorter alias for `trimmedCount()`.
+     */
+    static tc(p1: number, p2?: number): string;
+    /**
+     * Trimmed sum (TS) is the sum of the values of data points in a chosen range for a trimmed mean statistic.
+     * It is equivalent to `(Trimmed Mean) * (Trimmed count)`.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in percentages,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `ts(90)` returns the sum of the data points not including any
+     * data points that fall in the highest 10% of the values.  `ts(10, 90)`
+     * returns the sum of the data points not including any data points that fall
+     * in the lowest 10% of the values and the highest 90% of the values.
+     */
+    static trimmedSum(p1: number, p2?: number): string;
+    /**
+     * Shorter alias for `trimmedSum()`.
+     */
+    static ts(p1: number, p2?: number): string;
+    /**
+     * Percentile rank (PR) is the percentage of values that meet a fixed threshold.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in absolute values,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `percentileRank(300)` returns the percentage of data points that have a value of 300 or less.
+     * `percentileRank(100, 2000)` returns the percentage of data points that have a value between 100 and 2000.
+     */
+    static percentileRank(v1: number, v2?: number): string;
+    /**
+     * Shorter alias for `percentileRank()`.
+     */
+    static pr(v1: number, v2?: number): string;
+}

package/lib/aws/cloudwatch/stats.js

@@ -0,0 +1,207 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stats = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Factory functions for standard statistics strings
+ */
+class Stats {
+    /**
+     * Percentile indicates the relative standing of a value in a dataset.
+     *
+     * Percentiles help you get a better understanding of the distribution of your metric data.
+     *
+     * For example, `p(90)` is the 90th percentile and means that 90% of the data
+     * within the period is lower than this value and 10% of the data is higher
+     * than this value.
+     */
+    static percentile(percentile) {
+        assertPercentage(percentile);
+        return `p${percentile}`;
+    }
+    /**
+     * A shorter alias for `percentile()`.
+     */
+    static p(percentile) {
+        return Stats.percentile(percentile);
+    }
+    /**
+     * Trimmed mean (TM) is the mean of all values that are between two specified boundaries.
+     *
+     * Values outside of the boundaries are ignored when the mean is calculated.
+     * You define the boundaries as one or two numbers between 0 and 100, up to 10
+     * decimal places. The numbers are percentages.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in percentages,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `tm(90)` calculates the average after removing the 10% of data
+     * points with the highest values; `tm(10, 90)` calculates the average after removing the
+     * 10% with the lowest and 10% with the highest values.
+     */
+    static trimmedMean(p1, p2) {
+        return boundaryPercentileStat("tm", "TM", p1, p2);
+    }
+    /**
+     * A shorter alias for `trimmedMean()`.
+     */
+    static tm(p1, p2) {
+        return Stats.trimmedMean(p1, p2);
+    }
+    /**
+     * Winsorized mean (WM) is similar to trimmed mean.
+     *
+     * However, with winsorized mean, the values that are outside the boundary are
+     * not ignored, but instead are considered to be equal to the value at the
+     * edge of the appropriate boundary.  After this normalization, the average is
+     * calculated. You define the boundaries as one or two numbers between 0 and
+     * 100, up to 10 decimal places.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in percentages,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `tm(90)` calculates the average after removing the 10% of data
+     * points with the highest values; `tm(10, 90)` calculates the average after removing the
+     * 10% with the lowest and 10% with the highest values.
+     *
+     * For example, `wm(90)` calculates the average while treating the 10% of the
+     * highest values to be equal to the value at the 90th percentile.
+     * `wm(10, 90)` calculates the average while treaing the bottom 10% and the
+     * top 10% of values to be equal to the boundary values.
+     */
+    static winsorizedMean(p1, p2) {
+        return boundaryPercentileStat("wm", "WM", p1, p2);
+    }
+    /**
+     * A shorter alias for `winsorizedMean()`.
+     */
+    static wm(p1, p2) {
+        return Stats.winsorizedMean(p1, p2);
+    }
+    /**
+     * Trimmed count (TC) is the number of data points in the chosen range for a trimmed mean statistic.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in percentages,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `tc(90)` returns the number of data points not including any
+     * data points that fall in the highest 10% of the values. `tc(10, 90)`
+     * returns the number of data points not including any data points that fall
+     * in the lowest 10% of the values and the highest 90% of the values.
+     */
+    static trimmedCount(p1, p2) {
+        return boundaryPercentileStat("tc", "TC", p1, p2);
+    }
+    /**
+     * Shorter alias for `trimmedCount()`.
+     */
+    static tc(p1, p2) {
+        return Stats.trimmedCount(p1, p2);
+    }
+    /**
+     * Trimmed sum (TS) is the sum of the values of data points in a chosen range for a trimmed mean statistic.
+     * It is equivalent to `(Trimmed Mean) * (Trimmed count)`.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in percentages,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `ts(90)` returns the sum of the data points not including any
+     * data points that fall in the highest 10% of the values.  `ts(10, 90)`
+     * returns the sum of the data points not including any data points that fall
+     * in the lowest 10% of the values and the highest 90% of the values.
+     */
+    static trimmedSum(p1, p2) {
+        return boundaryPercentileStat("ts", "TS", p1, p2);
+    }
+    /**
+     * Shorter alias for `trimmedSum()`.
+     */
+    static ts(p1, p2) {
+        return Stats.trimmedSum(p1, p2);
+    }
+    /**
+     * Percentile rank (PR) is the percentage of values that meet a fixed threshold.
+     *
+     * - If two numbers are given, they define the lower and upper bounds in absolute values,
+     *   respectively.
+     * - If one number is given, it defines the upper bound (the lower bound is assumed to
+     *   be 0).
+     *
+     * For example, `percentileRank(300)` returns the percentage of data points that have a value of 300 or less.
+     * `percentileRank(100, 2000)` returns the percentage of data points that have a value between 100 and 2000.
+     */
+    static percentileRank(v1, v2) {
+        if (v2 !== undefined) {
+            return `PR(${v1}:${v2})`;
+        }
+        else {
+            return `PR(:${v1})`;
+        }
+    }
+    /**
+     * Shorter alias for `percentileRank()`.
+     */
+    static pr(v1, v2) {
+        return this.percentileRank(v1, v2);
+    }
+}
+exports.Stats = Stats;
+_a = JSII_RTTI_SYMBOL_1;
+Stats[_a] = { fqn: "terraconstructs.aws.cloudwatch.Stats", version: "0.0.8" };
+/**
+ * The count (number) of data points used for the statistical calculation.
+ */
+Stats.SAMPLE_COUNT = "SampleCount";
+/**
+ * The value of Sum / SampleCount during the specified period.
+ */
+Stats.AVERAGE = "Average";
+/**
+ * All values submitted for the matching metric added together.
+ * This statistic can be useful for determining the total volume of a metric.
+ */
+Stats.SUM = "Sum";
+/**
+ * The lowest value observed during the specified period.
+ * You can use this value to determine low volumes of activity for your application.
+ */
+Stats.MINIMUM = "Minimum";
+/**
+ * The highest value observed during the specified period.
+ * You can use this value to determine high volumes of activity for your application.
+ */
+Stats.MAXIMUM = "Maximum";
+/**
+ * Interquartile mean (IQM) is the trimmed mean of the interquartile range, or the middle 50% of values.
+ *
+ * It is equivalent to `trimmedMean(25, 75)`.
+ */
+Stats.IQM = "IQM";
+function assertPercentage(x) {
+    if (x !== undefined && (x < 0 || x > 100)) {
+        throw new Error(`Expecting a percentage, got: ${x}`);
+    }
+}
+/**
+ * Formatting helper because all these stats look the same
+ */
+function boundaryPercentileStat(oneBoundaryStat, twoBoundaryStat, p1, p2) {
+    assertPercentage(p1);
+    assertPercentage(p2);
+    if (p2 !== undefined) {
+        return `${twoBoundaryStat}(${p1}%:${p2}%)`;
+    }
+    else {
+        return `${oneBoundaryStat}${p1}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stats.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/stats.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Factory functions for standard statistics strings\n */\nexport abstract class Stats {\n  /**\n   * The count (number) of data points used for the statistical calculation.\n   */\n  public static readonly SAMPLE_COUNT = \"SampleCount\";\n\n  /**\n   * The value of Sum / SampleCount during the specified period.\n   */\n  public static readonly AVERAGE = \"Average\";\n  /**\n   * All values submitted for the matching metric added together.\n   * This statistic can be useful for determining the total volume of a metric.\n   */\n  public static readonly SUM = \"Sum\";\n\n  /**\n   * The lowest value observed during the specified period.\n   * You can use this value to determine low volumes of activity for your application.\n   */\n  public static readonly MINIMUM = \"Minimum\";\n\n  /**\n   * The highest value observed during the specified period.\n   * You can use this value to determine high volumes of activity for your application.\n   */\n  public static readonly MAXIMUM = \"Maximum\";\n\n  /**\n   * Interquartile mean (IQM) is the trimmed mean of the interquartile range, or the middle 50% of values.\n   *\n   * It is equivalent to `trimmedMean(25, 75)`.\n   */\n  public static readonly IQM = \"IQM\";\n\n  /**\n   * Percentile indicates the relative standing of a value in a dataset.\n   *\n   * Percentiles help you get a better understanding of the distribution of your metric data.\n   *\n   * For example, `p(90)` is the 90th percentile and means that 90% of the data\n   * within the period is lower than this value and 10% of the data is higher\n   * than this value.\n   */\n  public static percentile(percentile: number) {\n    assertPercentage(percentile);\n    return `p${percentile}`;\n  }\n\n  /**\n   * A shorter alias for `percentile()`.\n   */\n  public static p(percentile: number) {\n    return Stats.percentile(percentile);\n  }\n\n  /**\n   * Trimmed mean (TM) is the mean of all values that are between two specified boundaries.\n   *\n   * Values outside of the boundaries are ignored when the mean is calculated.\n   * You define the boundaries as one or two numbers between 0 and 100, up to 10\n   * decimal places. The numbers are percentages.\n   *\n   * - If two numbers are given, they define the lower and upper bounds in percentages,\n   *   respectively.\n   * - If one number is given, it defines the upper bound (the lower bound is assumed to\n   *   be 0).\n   *\n   * For example, `tm(90)` calculates the average after removing the 10% of data\n   * points with the highest values; `tm(10, 90)` calculates the average after removing the\n   * 10% with the lowest and 10% with the highest values.\n   */\n  public static trimmedMean(p1: number, p2?: number) {\n    return boundaryPercentileStat(\"tm\", \"TM\", p1, p2);\n  }\n\n  /**\n   * A shorter alias for `trimmedMean()`.\n   */\n  public static tm(p1: number, p2?: number) {\n    return Stats.trimmedMean(p1, p2);\n  }\n\n  /**\n   * Winsorized mean (WM) is similar to trimmed mean.\n   *\n   * However, with winsorized mean, the values that are outside the boundary are\n   * not ignored, but instead are considered to be equal to the value at the\n   * edge of the appropriate boundary.  After this normalization, the average is\n   * calculated. You define the boundaries as one or two numbers between 0 and\n   * 100, up to 10 decimal places.\n   *\n   * - If two numbers are given, they define the lower and upper bounds in percentages,\n   *   respectively.\n   * - If one number is given, it defines the upper bound (the lower bound is assumed to\n   *   be 0).\n   *\n   * For example, `tm(90)` calculates the average after removing the 10% of data\n   * points with the highest values; `tm(10, 90)` calculates the average after removing the\n   * 10% with the lowest and 10% with the highest values.\n   *\n   * For example, `wm(90)` calculates the average while treating the 10% of the\n   * highest values to be equal to the value at the 90th percentile.\n   * `wm(10, 90)` calculates the average while treaing the bottom 10% and the\n   * top 10% of values to be equal to the boundary values.\n   */\n  public static winsorizedMean(p1: number, p2?: number) {\n    return boundaryPercentileStat(\"wm\", \"WM\", p1, p2);\n  }\n\n  /**\n   * A shorter alias for `winsorizedMean()`.\n   */\n  public static wm(p1: number, p2?: number) {\n    return Stats.winsorizedMean(p1, p2);\n  }\n\n  /**\n   * Trimmed count (TC) is the number of data points in the chosen range for a trimmed mean statistic.\n   *\n   * - If two numbers are given, they define the lower and upper bounds in percentages,\n   *   respectively.\n   * - If one number is given, it defines the upper bound (the lower bound is assumed to\n   *   be 0).\n   *\n   * For example, `tc(90)` returns the number of data points not including any\n   * data points that fall in the highest 10% of the values. `tc(10, 90)`\n   * returns the number of data points not including any data points that fall\n   * in the lowest 10% of the values and the highest 90% of the values.\n   */\n  public static trimmedCount(p1: number, p2?: number) {\n    return boundaryPercentileStat(\"tc\", \"TC\", p1, p2);\n  }\n\n  /**\n   * Shorter alias for `trimmedCount()`.\n   */\n  public static tc(p1: number, p2?: number) {\n    return Stats.trimmedCount(p1, p2);\n  }\n\n  /**\n   * Trimmed sum (TS) is the sum of the values of data points in a chosen range for a trimmed mean statistic.\n   * It is equivalent to `(Trimmed Mean) * (Trimmed count)`.\n   *\n   * - If two numbers are given, they define the lower and upper bounds in percentages,\n   *   respectively.\n   * - If one number is given, it defines the upper bound (the lower bound is assumed to\n   *   be 0).\n   *\n   * For example, `ts(90)` returns the sum of the data points not including any\n   * data points that fall in the highest 10% of the values.  `ts(10, 90)`\n   * returns the sum of the data points not including any data points that fall\n   * in the lowest 10% of the values and the highest 90% of the values.\n   */\n  public static trimmedSum(p1: number, p2?: number) {\n    return boundaryPercentileStat(\"ts\", \"TS\", p1, p2);\n  }\n\n  /**\n   * Shorter alias for `trimmedSum()`.\n   */\n  public static ts(p1: number, p2?: number) {\n    return Stats.trimmedSum(p1, p2);\n  }\n\n  /**\n   * Percentile rank (PR) is the percentage of values that meet a fixed threshold.\n   *\n   * - If two numbers are given, they define the lower and upper bounds in absolute values,\n   *   respectively.\n   * - If one number is given, it defines the upper bound (the lower bound is assumed to\n   *   be 0).\n   *\n   * For example, `percentileRank(300)` returns the percentage of data points that have a value of 300 or less.\n   * `percentileRank(100, 2000)` returns the percentage of data points that have a value between 100 and 2000.\n   */\n  public static percentileRank(v1: number, v2?: number) {\n    if (v2 !== undefined) {\n      return `PR(${v1}:${v2})`;\n    } else {\n      return `PR(:${v1})`;\n    }\n  }\n\n  /**\n   * Shorter alias for `percentileRank()`.\n   */\n  public static pr(v1: number, v2?: number) {\n    return this.percentileRank(v1, v2);\n  }\n}\n\nfunction assertPercentage(x?: number) {\n  if (x !== undefined && (x < 0 || x > 100)) {\n    throw new Error(`Expecting a percentage, got: ${x}`);\n  }\n}\n\n/**\n * Formatting helper because all these stats look the same\n */\nfunction boundaryPercentileStat(\n  oneBoundaryStat: string,\n  twoBoundaryStat: string,\n  p1: number,\n  p2: number | undefined,\n) {\n  assertPercentage(p1);\n  assertPercentage(p2);\n  if (p2 !== undefined) {\n    return `${twoBoundaryStat}(${p1}%:${p2}%)`;\n  } else {\n    return `${oneBoundaryStat}${p1}`;\n  }\n}\n"]}

package/lib/aws/cloudwatch/subscription-filter.d.ts

@@ -0,0 +1,75 @@
+import { cloudwatchLogSubscriptionFilter } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps } from "..";
+import { ILogGroup, SubscriptionFilterOptions } from "./log-group";
+import * as iam from "../iam";
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface LogSubscriptionDestinationOutputs {
+    /**
+     * The arn of this log group
+     * @attribute
+     */
+    readonly logGroupArn: string;
+    /**
+     * The name of this log group
+     * @attribute
+     */
+    readonly logGroupName: string;
+}
+/**
+ * Interface for classes that can be the destination of a log Subscription
+ */
+export interface ILogSubscriptionDestination {
+    /**
+     * Return the properties required to send subscription events to this destination.
+     *
+     * If necessary, the destination can use the properties of the SubscriptionFilter
+     * object itself to configure its permissions to allow the subscription to write
+     * to it.
+     *
+     * The destination may reconfigure its own permissions in response to this
+     * function call.
+     */
+    bind(scope: Construct, sourceLogGroup: ILogGroup): LogSubscriptionDestinationConfig;
+}
+/**
+ * Properties returned by a Subscription destination
+ */
+export interface LogSubscriptionDestinationConfig {
+    /**
+     * The ARN of the subscription's destination
+     */
+    readonly arn: string;
+    /**
+     * The role to assume to write log events to the destination
+     *
+     * @default No role assumed
+     */
+    readonly role?: iam.IRole;
+    /**
+     * Dependencies required for subscription filter creation to succeed
+     */
+    readonly dependencies?: Construct[];
+}
+/**
+ * Properties for a SubscriptionFilter
+ */
+export interface SubscriptionFilterProps extends SubscriptionFilterOptions, AwsConstructProps {
+    /**
+     * The log group to create the subscription on.
+     */
+    readonly logGroup: ILogGroup;
+}
+/**
+ * A new Subscription on a CloudWatch log group.
+ */
+export declare class SubscriptionFilter extends AwsConstructBase {
+    resource: cloudwatchLogSubscriptionFilter.CloudwatchLogSubscriptionFilter;
+    /**
+     * This resource exports no additional attributes.
+     */
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: SubscriptionFilterProps);
+}

package/lib/aws/cloudwatch/subscription-filter.js

@@ -0,0 +1,51 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionFilter = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-logs/lib/subscription-filter.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+const log_destinations_1 = require("./log-destinations");
+/**
+ * A new Subscription on a CloudWatch log group.
+ */
+class SubscriptionFilter extends __1.AwsConstructBase {
+    /**
+     * This resource exports no additional attributes.
+     */
+    get outputs() {
+        return {};
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const name = props.filterName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        if (props.distribution &&
+            !cdktf_1.Token.isUnresolved(props.distribution) &&
+            !cdktf_1.Token.isUnresolved(props.destination) &&
+            !(props.destination instanceof log_destinations_1.KinesisDestination)) {
+            throw new Error("distribution property can only be used with KinesisDestination.");
+        }
+        const destProps = props.destination.bind(this, props.logGroup);
+        this.resource =
+            new provider_aws_1.cloudwatchLogSubscriptionFilter.CloudwatchLogSubscriptionFilter(this, "Resource", {
+                name,
+                logGroupName: props.logGroup.logGroupName,
+                destinationArn: destProps.arn,
+                roleArn: destProps.role && destProps.role.roleArn,
+                filterPattern: props.filterPattern.logPatternString,
+                distribution: props.distribution,
+            });
+        if (destProps.dependencies) {
+            this.resource.node.addDependency(...destProps.dependencies);
+        }
+    }
+}
+exports.SubscriptionFilter = SubscriptionFilter;
+_a = JSII_RTTI_SYMBOL_1;
+SubscriptionFilter[_a] = { fqn: "terraconstructs.aws.cloudwatch.SubscriptionFilter", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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