terraconstructs 0.0.8

package/lib/aws/cloudwatch/log-group.js

@@ -0,0 +1,350 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogGroup = exports.Distribution = exports.LogGroupClass = 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/log-group.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const log_retention_1 = require("../log-retention");
+const log_stream_1 = require("./log-stream");
+const metric_1 = require("./metric");
+const metric_filter_1 = require("./metric-filter");
+const pattern_1 = require("./pattern");
+const policy_1 = require("./policy");
+const subscription_filter_1 = require("./subscription-filter");
+const iam = require("../iam");
+/**
+ * An CloudWatch Log Group
+ */
+class LogGroupBase extends aws_construct_1.AwsConstructBase {
+    get logGroupOutputs() {
+        return {
+            logGroupArn: this.logGroupArn,
+            logGroupName: this.logGroupName,
+        };
+    }
+    get outputs() {
+        return this.logGroupOutputs;
+    }
+    /**
+     * Create a new Log Stream for this Log Group
+     *
+     * @param id Unique identifier for the construct in its parent
+     * @param props Properties for creating the LogStream
+     */
+    addStream(id, props = {}) {
+        return new log_stream_1.LogStream(this, id, {
+            logGroup: this,
+            ...props,
+        });
+    }
+    /**
+     * Create a new Subscription Filter on this Log Group
+     *
+     * @param id Unique identifier for the construct in its parent
+     * @param props Properties for creating the SubscriptionFilter
+     */
+    addSubscriptionFilter(id, props) {
+        return new subscription_filter_1.SubscriptionFilter(this, id, {
+            logGroup: this,
+            ...props,
+        });
+    }
+    /**
+     * Create a new Metric Filter on this Log Group
+     *
+     * @param id Unique identifier for the construct in its parent
+     * @param props Properties for creating the MetricFilter
+     */
+    addMetricFilter(id, props) {
+        return new metric_filter_1.MetricFilter(this, id, {
+            logGroup: this,
+            ...props,
+        });
+    }
+    /**
+     * Extract a metric from structured log events in the LogGroup
+     *
+     * Creates a MetricFilter on this LogGroup that will extract the value
+     * of the indicated JSON field in all records where it occurs.
+     *
+     * The metric will be available in CloudWatch Metrics under the
+     * indicated namespace and name.
+     *
+     * @param jsonField JSON field to extract (example: '$.myfield')
+     * @param metricNamespace Namespace to emit the metric under
+     * @param metricName Name to emit the metric under
+     * @returns A Metric object representing the extracted metric
+     */
+    extractMetric(jsonField, metricNamespace, metricName) {
+        new metric_filter_1.MetricFilter(this, `${metricNamespace}_${metricName}`, {
+            logGroup: this,
+            metricNamespace,
+            metricName,
+            filterPattern: pattern_1.FilterPattern.exists(jsonField),
+            metricValue: jsonField,
+        });
+        return new metric_1.Metric({
+            metricName,
+            namespace: metricNamespace,
+        }).attachTo(this);
+    }
+    /**
+     * Give permissions to create and write to streams in this log group
+     */
+    grantWrite(grantee) {
+        return this.grant(grantee, "logs:CreateLogStream", "logs:PutLogEvents");
+    }
+    /**
+     * Give permissions to read and filter events from this log group
+     */
+    grantRead(grantee) {
+        return this.grant(grantee, "logs:FilterLogEvents", "logs:GetLogEvents", "logs:GetLogGroupFields", "logs:DescribeLogGroups", "logs:DescribeLogStreams");
+    }
+    /**
+     * Give the indicated permissions on this log group and all streams
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions,
+            // A LogGroup ARN out of CloudFormation already includes a ':*' at the end to include the log streams under the group.
+            // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-logs-loggroup.html#w2ab1c21c10c63c43c11
+            resourceArns: [this.logGroupArn],
+            resource: this,
+        });
+    }
+    /**
+     * Public method to get the physical name of this log group
+     * @returns Physical name of log group
+     */
+    logGroupPhysicalName() {
+        return this.logGroupName;
+    }
+    /**
+     * Adds a statement to the resource policy associated with this log group.
+     * A resource policy will be automatically created upon the first call to `addToResourcePolicy`.
+     *
+     * Any ARN Principals inside of the statement will be converted into AWS Account ID strings
+     * because CloudWatch Logs Resource Policies do not accept ARN principals.
+     *
+     * @param statement The policy statement to add
+     */
+    addToResourcePolicy(statement) {
+        if (!this.policy) {
+            this.policy = new policy_1.ResourcePolicy(this, "Policy");
+        }
+        this.policy.document.addStatements(statement.copy({
+            principals: statement.principals.map((p) => this.convertArnPrincipalToAccountId(p)),
+        }));
+        return { statementAdded: true, policyDependable: this.policy };
+    }
+    convertArnPrincipalToAccountId(principal) {
+        if (principal.principalAccount) {
+            // we use ArnPrincipal here because the constructor inserts the argument
+            // into the template without mutating it, which means that there is no
+            // ARN created by this call.
+            return new iam.ArnPrincipal(principal.principalAccount);
+        }
+        if (principal instanceof iam.ArnPrincipal && principal.arn !== "*") {
+            const parsedArn = arn_1.Arn.split(principal.arn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+            if (parsedArn.account) {
+                return new iam.ArnPrincipal(parsedArn.account);
+            }
+        }
+        return principal;
+    }
+    /**
+     * Creates a CloudWatch metric for the number of incoming log events to this log group.
+     *
+     * @param props - Optional. Configuration options for the metric.
+     * @returns A CloudWatch Metric object representing the IncomingLogEvents metric.
+     *
+     * This method allows you to monitor the rate at which log events are being ingested
+     * into the log group. It's useful for understanding the volume of logging activity
+     * and can help in capacity planning or detecting unusual spikes in logging.
+     *
+     * Example usage:
+     * ```
+     * const logGroup = new logs.LogGroup(this, 'MyLogGroup');
+     * logGroup.metricIncomingLogEvents().createAlarm(stack, 'IncomingEventsPerInstanceAlarm', {
+     * threshold: 1,
+     * evaluationPeriods: 1,
+     * });
+     * ```
+     */
+    metricIncomingLogEvents(props) {
+        return this.metric("IncomingLogs", props);
+    }
+    /**
+     * Creates a CloudWatch metric for the volume of incoming log data in bytes to this log group.
+     *
+     * @param props - Optional. Configuration options for the metric.
+     * @returns A CloudWatch Metric object representing the IncomingBytes metric.
+     *
+     * This method allows you to monitor the volume of data being ingested into the log group.
+     * It's useful for understanding the size of your logs, which can impact storage costs
+     * and help in identifying unexpectedly large log entries.
+     *
+     * Example usage:
+     * ```
+     * const logGroup = new logs.LogGroup(this, 'MyLogGroup');
+     * logGroup.metricIncomingBytes().createAlarm(stack, 'IncomingBytesPerInstanceAlarm', {
+     *   threshold: 1,
+     *   evaluationPeriods: 1,
+     * });
+     * ```
+     */
+    metricIncomingBytes(props) {
+        return this.metric("IncomingBytes", props);
+    }
+    /**
+     * Creates a CloudWatch metric for this log group.
+     *
+     * @param metricName - The name of the metric to create.
+     * @param props - Optional. Additional properties to configure the metric.
+     * @returns A CloudWatch Metric object representing the specified metric for this log group.
+     *
+     * This method creates a CloudWatch Metric object with predefined settings for the log group.
+     * It sets the namespace to 'AWS/Logs' and the statistic to 'Sum' by default.
+     *
+     * The created metric is automatically associated with this log group using the `attachTo` method.
+     *
+     * Common metric names for log groups include:
+     * - 'IncomingBytes': The volume of log data in bytes ingested into the log group.
+     * - 'IncomingLogEvents': The number of log events ingested into the log group.
+     * ```
+     */
+    metric(metricName, props) {
+        return new metric_1.Metric({
+            namespace: "AWS/Logs",
+            metricName,
+            statistic: "Sum",
+            ...props,
+        }).attachTo(this);
+    }
+}
+/**
+ * Class of Log Group.
+ */
+var LogGroupClass;
+(function (LogGroupClass) {
+    /**
+     * Default class of logs services
+     */
+    LogGroupClass["STANDARD"] = "STANDARD";
+    /**
+     * Class for reduced logs services
+     */
+    LogGroupClass["INFREQUENT_ACCESS"] = "INFREQUENT_ACCESS";
+})(LogGroupClass || (exports.LogGroupClass = LogGroupClass = {}));
+/**
+ * The method used to distribute log data to the destination.
+ */
+var Distribution;
+(function (Distribution) {
+    /**
+     * Log events from the same log stream are kept together and sent to the same destination.
+     */
+    Distribution["BY_LOG_STREAM"] = "ByLogStream";
+    /**
+     * Log events are distributed across the log destinations randomly.
+     */
+    Distribution["RANDOM"] = "Random";
+})(Distribution || (exports.Distribution = Distribution = {}));
+/**
+ * Define a CloudWatch Log Group
+ */
+class LogGroup extends LogGroupBase {
+    /**
+     * Import an existing LogGroup given its ARN
+     */
+    static fromLogGroupArn(scope, id, logGroupArn) {
+        const baseLogGroupArn = logGroupArn.replace(/:\*$/, "");
+        class Import extends LogGroupBase {
+            constructor() {
+                super(...arguments);
+                this.logGroupArn = `${baseLogGroupArn}:*`;
+                this.logGroupName = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(baseLogGroupArn, arn_1.ArnFormat.COLON_RESOURCE_NAME).resourceName;
+            }
+        }
+        return new Import(scope, id, {
+            environmentFromArn: baseLogGroupArn,
+        });
+    }
+    /**
+     * Import an existing LogGroup given its name
+     */
+    static fromLogGroupName(scope, id, logGroupName) {
+        const baseLogGroupName = logGroupName.replace(/:\*$/, "");
+        class Import extends LogGroupBase {
+            constructor() {
+                super(...arguments);
+                this.logGroupName = baseLogGroupName;
+                this.logGroupArn = aws_stack_1.AwsStack.ofAwsConstruct(scope).formatArn({
+                    service: "logs",
+                    resource: "log-group",
+                    arnFormat: arn_1.ArnFormat.COLON_RESOURCE_NAME,
+                    resourceName: baseLogGroupName + ":*",
+                });
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        const name = props.logGroupName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        let retentionInDays = props.retention;
+        let skipDestroy = props.skipDestroy;
+        if (retentionInDays === undefined) {
+            retentionInDays = log_retention_1.RetentionDays.TWO_YEARS;
+        }
+        if (retentionInDays === Infinity ||
+            retentionInDays === log_retention_1.RetentionDays.INFINITE) {
+            retentionInDays = undefined;
+            skipDestroy = props.skipDestroy ?? true;
+        }
+        if (retentionInDays !== undefined &&
+            !cdktf_1.Token.isUnresolved(retentionInDays) &&
+            retentionInDays <= 0) {
+            throw new Error(`retentionInDays must be positive, got ${retentionInDays}`);
+        }
+        let logGroupClass = props.logGroupClass;
+        const logGroupClassUnsupportedRegions = [
+            "us-iso-west-1", // APA
+            "us-iso-east-1", // DCA
+            "us-isob-east-1", // LCK
+        ];
+        if (logGroupClass !== undefined &&
+            !cdktf_1.Token.isUnresolved(this.stack.region) &&
+            logGroupClassUnsupportedRegions.includes(this.stack.region)) {
+            // "@aws-cdk/aws-logs:propertyNotSupported",
+            cdktf_1.Annotations.of(this).addWarning(`The LogGroupClass property is not supported in the following regions: ${logGroupClassUnsupportedRegions}`);
+        }
+        this.resource = new provider_aws_1.cloudwatchLogGroup.CloudwatchLogGroup(this, "Resource", {
+            name,
+            logGroupClass,
+            retentionInDays,
+            skipDestroy,
+            kmsKeyId: props.encryptionKey?.keyArn,
+        });
+        // https://registry.terraform.io/providers/hashicorp/aws/5.82.1/docs/resources/cloudwatch_log_group#attribute-reference
+        // terraform-provider-aws drops the trailing ':*' from the ARN when returning it as an attribute
+        this.logGroupArn = `${this.resource.arn}:*`;
+        this.logGroupName = this.resource.name;
+        if (props.dataProtectionPolicy) {
+            props.dataProtectionPolicy?._bind(this);
+        }
+    }
+}
+exports.LogGroup = LogGroup;
+_a = JSII_RTTI_SYMBOL_1;
+LogGroup[_a] = { fqn: "terraconstructs.aws.cloudwatch.LogGroup", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log-group.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/log-group.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/log-group.ts\n\nimport { cloudwatchLogGroup } from \"@cdktf/provider-aws\";\nimport { Annotations, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Arn, ArnFormat } from \"../arn\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { RetentionDays } from \"../log-retention\";\nimport { DataProtectionPolicy } from \"./data-protection-policy\";\nimport { LogStream } from \"./log-stream\";\nimport { Metric, MetricOptions } from \"./metric\";\nimport { MetricFilter } from \"./metric-filter\";\nimport { Unit } from \"./metric-types\";\nimport { FilterPattern, IFilterPattern } from \"./pattern\";\nimport { ResourcePolicy } from \"./policy\";\nimport {\n  ILogSubscriptionDestination,\n  SubscriptionFilter,\n} from \"./subscription-filter\";\nimport * as kms from \"../encryption\";\nimport * as iam from \"../iam\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface LogGroupOutputs {\n  /**\n   * The arn of this log group\n   * @attribute\n   */\n  readonly logGroupArn: string;\n  /**\n   * The name of this log group\n   * @attribute\n   */\n  readonly logGroupName: string;\n}\n\nexport interface ILogGroup extends iam.IAwsConstructWithPolicy {\n  /** Strongly typed outputs */\n  readonly logGroupOutputs: LogGroupOutputs;\n\n  /**\n   * The ARN of this log group, with ':*' appended\n   *\n   * @attribute\n   */\n  readonly logGroupArn: string;\n\n  /**\n   * The name of this log group\n   * @attribute\n   */\n  readonly logGroupName: string;\n\n  /**\n   * Create a new Log Stream for this Log Group\n   *\n   * @param id Unique identifier for the construct in its parent\n   * @param props Properties for creating the LogStream\n   */\n  addStream(id: string, props?: StreamOptions): LogStream;\n\n  /**\n   * Create a new Subscription Filter on this Log Group\n   *\n   * @param id Unique identifier for the construct in its parent\n   * @param props Properties for creating the SubscriptionFilter\n   */\n  addSubscriptionFilter(\n    id: string,\n    props: SubscriptionFilterOptions,\n  ): SubscriptionFilter;\n\n  /**\n   * Create a new Metric Filter on this Log Group\n   *\n   * @param id Unique identifier for the construct in its parent\n   * @param props Properties for creating the MetricFilter\n   */\n  addMetricFilter(id: string, props: MetricFilterOptions): MetricFilter;\n\n  /**\n   * Extract a metric from structured log events in the LogGroup\n   *\n   * Creates a MetricFilter on this LogGroup that will extract the value\n   * of the indicated JSON field in all records where it occurs.\n   *\n   * The metric will be available in CloudWatch Metrics under the\n   * indicated namespace and name.\n   *\n   * @param jsonField JSON field to extract (example: '$.myfield')\n   * @param metricNamespace Namespace to emit the metric under\n   * @param metricName Name to emit the metric under\n   * @returns A Metric object representing the extracted metric\n   */\n  extractMetric(\n    jsonField: string,\n    metricNamespace: string,\n    metricName: string,\n  ): Metric;\n\n  /**\n   * Give permissions to write to create and write to streams in this log group\n   */\n  grantWrite(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Give permissions to read from this log group and streams\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Give the indicated permissions on this log group and all streams\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Public method to get the physical name of this log group\n   */\n  logGroupPhysicalName(): string;\n\n  /**\n   * Return the given named metric for this Log Group\n   *\n   * @param metricName The name of the metric\n   * @param props Properties for the metric\n   */\n  metric(metricName: string, props?: MetricOptions): Metric;\n\n  /**\n   * The number of log events uploaded to CloudWatch Logs.\n   * When used with the LogGroupName dimension, this is the number of\n   * log events uploaded to the log group.\n   *\n   * @param props Properties for the Cloudwatch metric\n   */\n  metricIncomingLogEvents(props?: MetricOptions): Metric;\n\n  /**\n   * The volume of log events in uncompressed bytes uploaded to CloudWatch Logs.\n   * When used with the LogGroupName dimension, this is the volume of log events\n   * in uncompressed bytes uploaded to the log group.\n   *\n   * @param props Properties for the Cloudwatch metric\n   */\n  metricIncomingBytes(props?: MetricOptions): Metric;\n}\n\n/**\n * An CloudWatch Log Group\n */\nabstract class LogGroupBase extends AwsConstructBase implements ILogGroup {\n  /**\n   * The ARN of this log group, with ':*' appended\n   */\n  public abstract readonly logGroupArn: string;\n\n  /**\n   * The name of this log group\n   */\n  public abstract readonly logGroupName: string;\n\n  public get logGroupOutputs(): LogGroupOutputs {\n    return {\n      logGroupArn: this.logGroupArn,\n      logGroupName: this.logGroupName,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.logGroupOutputs;\n  }\n\n  private policy?: ResourcePolicy;\n\n  /**\n   * Create a new Log Stream for this Log Group\n   *\n   * @param id Unique identifier for the construct in its parent\n   * @param props Properties for creating the LogStream\n   */\n  public addStream(id: string, props: StreamOptions = {}): LogStream {\n    return new LogStream(this, id, {\n      logGroup: this,\n      ...props,\n    });\n  }\n\n  /**\n   * Create a new Subscription Filter on this Log Group\n   *\n   * @param id Unique identifier for the construct in its parent\n   * @param props Properties for creating the SubscriptionFilter\n   */\n  public addSubscriptionFilter(\n    id: string,\n    props: SubscriptionFilterOptions,\n  ): SubscriptionFilter {\n    return new SubscriptionFilter(this, id, {\n      logGroup: this,\n      ...props,\n    });\n  }\n\n  /**\n   * Create a new Metric Filter on this Log Group\n   *\n   * @param id Unique identifier for the construct in its parent\n   * @param props Properties for creating the MetricFilter\n   */\n  public addMetricFilter(id: string, props: MetricFilterOptions): MetricFilter {\n    return new MetricFilter(this, id, {\n      logGroup: this,\n      ...props,\n    });\n  }\n\n  /**\n   * Extract a metric from structured log events in the LogGroup\n   *\n   * Creates a MetricFilter on this LogGroup that will extract the value\n   * of the indicated JSON field in all records where it occurs.\n   *\n   * The metric will be available in CloudWatch Metrics under the\n   * indicated namespace and name.\n   *\n   * @param jsonField JSON field to extract (example: '$.myfield')\n   * @param metricNamespace Namespace to emit the metric under\n   * @param metricName Name to emit the metric under\n   * @returns A Metric object representing the extracted metric\n   */\n  public extractMetric(\n    jsonField: string,\n    metricNamespace: string,\n    metricName: string,\n  ) {\n    new MetricFilter(this, `${metricNamespace}_${metricName}`, {\n      logGroup: this,\n      metricNamespace,\n      metricName,\n      filterPattern: FilterPattern.exists(jsonField),\n      metricValue: jsonField,\n    });\n\n    return new Metric({\n      metricName,\n      namespace: metricNamespace,\n    }).attachTo(this);\n  }\n\n  /**\n   * Give permissions to create and write to streams in this log group\n   */\n  public grantWrite(grantee: iam.IGrantable) {\n    return this.grant(grantee, \"logs:CreateLogStream\", \"logs:PutLogEvents\");\n  }\n\n  /**\n   * Give permissions to read and filter events from this log group\n   */\n  public grantRead(grantee: iam.IGrantable) {\n    return this.grant(\n      grantee,\n      \"logs:FilterLogEvents\",\n      \"logs:GetLogEvents\",\n      \"logs:GetLogGroupFields\",\n      \"logs:DescribeLogGroups\",\n      \"logs:DescribeLogStreams\",\n    );\n  }\n\n  /**\n   * Give the indicated permissions on this log group and all streams\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]) {\n    return iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions,\n      // A LogGroup ARN out of CloudFormation already includes a ':*' at the end to include the log streams under the group.\n      // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-logs-loggroup.html#w2ab1c21c10c63c43c11\n      resourceArns: [this.logGroupArn],\n      resource: this,\n    });\n  }\n\n  /**\n   * Public method to get the physical name of this log group\n   * @returns Physical name of log group\n   */\n  public logGroupPhysicalName(): string {\n    return this.logGroupName;\n  }\n  /**\n   * Adds a statement to the resource policy associated with this log group.\n   * A resource policy will be automatically created upon the first call to `addToResourcePolicy`.\n   *\n   * Any ARN Principals inside of the statement will be converted into AWS Account ID strings\n   * because CloudWatch Logs Resource Policies do not accept ARN principals.\n   *\n   * @param statement The policy statement to add\n   */\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (!this.policy) {\n      this.policy = new ResourcePolicy(this, \"Policy\");\n    }\n    this.policy.document.addStatements(\n      statement.copy({\n        principals: statement.principals.map((p) =>\n          this.convertArnPrincipalToAccountId(p),\n        ),\n      }),\n    );\n    return { statementAdded: true, policyDependable: this.policy };\n  }\n\n  private convertArnPrincipalToAccountId(principal: iam.IPrincipal) {\n    if (principal.principalAccount) {\n      // we use ArnPrincipal here because the constructor inserts the argument\n      // into the template without mutating it, which means that there is no\n      // ARN created by this call.\n      return new iam.ArnPrincipal(principal.principalAccount);\n    }\n\n    if (principal instanceof iam.ArnPrincipal && principal.arn !== \"*\") {\n      const parsedArn = Arn.split(principal.arn, ArnFormat.SLASH_RESOURCE_NAME);\n      if (parsedArn.account) {\n        return new iam.ArnPrincipal(parsedArn.account);\n      }\n    }\n\n    return principal;\n  }\n\n  /**\n   * Creates a CloudWatch metric for the number of incoming log events to this log group.\n   *\n   * @param props - Optional. Configuration options for the metric.\n   * @returns A CloudWatch Metric object representing the IncomingLogEvents metric.\n   *\n   * This method allows you to monitor the rate at which log events are being ingested\n   * into the log group. It's useful for understanding the volume of logging activity\n   * and can help in capacity planning or detecting unusual spikes in logging.\n   *\n   * Example usage:\n   * ```\n   * const logGroup = new logs.LogGroup(this, 'MyLogGroup');\n   * logGroup.metricIncomingLogEvents().createAlarm(stack, 'IncomingEventsPerInstanceAlarm', {\n   * threshold: 1,\n   * evaluationPeriods: 1,\n   * });\n   * ```\n   */\n  public metricIncomingLogEvents(props?: MetricOptions): Metric {\n    return this.metric(\"IncomingLogs\", props);\n  }\n\n  /**\n   * Creates a CloudWatch metric for the volume of incoming log data in bytes to this log group.\n   *\n   * @param props - Optional. Configuration options for the metric.\n   * @returns A CloudWatch Metric object representing the IncomingBytes metric.\n   *\n   * This method allows you to monitor the volume of data being ingested into the log group.\n   * It's useful for understanding the size of your logs, which can impact storage costs\n   * and help in identifying unexpectedly large log entries.\n   *\n   * Example usage:\n   * ```\n   * const logGroup = new logs.LogGroup(this, 'MyLogGroup');\n   * logGroup.metricIncomingBytes().createAlarm(stack, 'IncomingBytesPerInstanceAlarm', {\n   *   threshold: 1,\n   *   evaluationPeriods: 1,\n   * });\n   * ```\n   */\n  public metricIncomingBytes(props?: MetricOptions): Metric {\n    return this.metric(\"IncomingBytes\", props);\n  }\n\n  /**\n   * Creates a CloudWatch metric for this log group.\n   *\n   * @param metricName - The name of the metric to create.\n   * @param props - Optional. Additional properties to configure the metric.\n   * @returns A CloudWatch Metric object representing the specified metric for this log group.\n   *\n   * This method creates a CloudWatch Metric object with predefined settings for the log group.\n   * It sets the namespace to 'AWS/Logs' and the statistic to 'Sum' by default.\n   *\n   * The created metric is automatically associated with this log group using the `attachTo` method.\n   *\n   * Common metric names for log groups include:\n   * - 'IncomingBytes': The volume of log data in bytes ingested into the log group.\n   * - 'IncomingLogEvents': The number of log events ingested into the log group.\n   * ```\n   */\n  public metric(metricName: string, props?: MetricOptions): Metric {\n    return new Metric({\n      namespace: \"AWS/Logs\",\n      metricName,\n      statistic: \"Sum\",\n      ...props,\n    }).attachTo(this);\n  }\n}\n\n/**\n * Class of Log Group.\n */\nexport enum LogGroupClass {\n  /**\n   * Default class of logs services\n   */\n  STANDARD = \"STANDARD\",\n\n  /**\n   * Class for reduced logs services\n   */\n  INFREQUENT_ACCESS = \"INFREQUENT_ACCESS\",\n}\n\n/**\n * Properties for a LogGroup\n */\nexport interface LogGroupProps extends AwsConstructProps {\n  /**\n   * The KMS customer managed key to encrypt the log group with.\n   *\n   * @default Server-side encryption managed by the CloudWatch Logs service\n   */\n  readonly encryptionKey?: kms.IKey;\n\n  /**\n   * Name of the log group.\n   *\n   * @default Automatically generated\n   */\n  readonly logGroupName?: string;\n\n  /**\n   * Data Protection Policy for this log group.\n   *\n   * @default - no data protection policy\n   */\n  readonly dataProtectionPolicy?: DataProtectionPolicy;\n\n  /**\n   * How long, in days, the log contents will be retained.\n   *\n   * To retain all logs, set this value to RetentionDays.INFINITE.\n   *\n   * @default RetentionDays.TWO_YEARS\n   */\n  readonly retention?: RetentionDays;\n\n  /**\n   * Set to true if you do not wish the log group (and any logs it may contain) to be deleted at destroy time, and instead just remove the log group from the Terraform state.\n   *\n   * @default false - unless `retention` is set to RetentionDays.INFINITE, in which case this is set to true\n   */\n  readonly skipDestroy?: boolean;\n\n  /**\n   * The class of the log group. Possible values are: STANDARD and INFREQUENT_ACCESS.\n   *\n   * INFREQUENT_ACCESS class provides customers a cost-effective way to consolidate\n   * logs which supports querying using Logs Insights. The logGroupClass property cannot\n   * be changed once the log group is created.\n   *\n   * @default LogGroupClass.STANDARD\n   */\n  readonly logGroupClass?: LogGroupClass;\n}\n\n/**\n * The method used to distribute log data to the destination.\n */\nexport enum Distribution {\n  /**\n   * Log events from the same log stream are kept together and sent to the same destination.\n   */\n  BY_LOG_STREAM = \"ByLogStream\",\n\n  /**\n   * Log events are distributed across the log destinations randomly.\n   */\n  RANDOM = \"Random\",\n}\n\n/**\n * Define a CloudWatch Log Group\n */\nexport class LogGroup extends LogGroupBase {\n  /**\n   * Import an existing LogGroup given its ARN\n   */\n  public static fromLogGroupArn(\n    scope: Construct,\n    id: string,\n    logGroupArn: string,\n  ): ILogGroup {\n    const baseLogGroupArn = logGroupArn.replace(/:\\*$/, \"\");\n\n    class Import extends LogGroupBase {\n      public readonly logGroupArn = `${baseLogGroupArn}:*`;\n      public readonly logGroupName = AwsStack.ofAwsConstruct(scope).splitArn(\n        baseLogGroupArn,\n        ArnFormat.COLON_RESOURCE_NAME,\n      ).resourceName!;\n    }\n\n    return new Import(scope, id, {\n      environmentFromArn: baseLogGroupArn,\n    });\n  }\n\n  /**\n   * Import an existing LogGroup given its name\n   */\n  public static fromLogGroupName(\n    scope: Construct,\n    id: string,\n    logGroupName: string,\n  ): ILogGroup {\n    const baseLogGroupName = logGroupName.replace(/:\\*$/, \"\");\n\n    class Import extends LogGroupBase {\n      public readonly logGroupName = baseLogGroupName;\n      public readonly logGroupArn = AwsStack.ofAwsConstruct(scope).formatArn({\n        service: \"logs\",\n        resource: \"log-group\",\n        arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n        resourceName: baseLogGroupName + \":*\",\n      });\n    }\n\n    return new Import(scope, id);\n  }\n\n  public readonly resource: cloudwatchLogGroup.CloudwatchLogGroup;\n\n  /**\n   * The ARN of this log group\n   */\n  public readonly logGroupArn: string;\n\n  /**\n   * The name of this log group\n   */\n  public readonly logGroupName: string;\n\n  constructor(scope: Construct, id: string, props: LogGroupProps = {}) {\n    super(scope, id, props);\n    const name =\n      props.logGroupName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    let retentionInDays = props.retention;\n    let skipDestroy = props.skipDestroy;\n    if (retentionInDays === undefined) {\n      retentionInDays = RetentionDays.TWO_YEARS;\n    }\n    if (\n      retentionInDays === Infinity ||\n      retentionInDays === RetentionDays.INFINITE\n    ) {\n      retentionInDays = undefined;\n      skipDestroy = props.skipDestroy ?? true;\n    }\n\n    if (\n      retentionInDays !== undefined &&\n      !Token.isUnresolved(retentionInDays) &&\n      retentionInDays <= 0\n    ) {\n      throw new Error(\n        `retentionInDays must be positive, got ${retentionInDays}`,\n      );\n    }\n\n    let logGroupClass = props.logGroupClass;\n\n    const logGroupClassUnsupportedRegions = [\n      \"us-iso-west-1\", // APA\n      \"us-iso-east-1\", // DCA\n      \"us-isob-east-1\", // LCK\n    ];\n    if (\n      logGroupClass !== undefined &&\n      !Token.isUnresolved(this.stack.region) &&\n      logGroupClassUnsupportedRegions.includes(this.stack.region)\n    ) {\n      // \"@aws-cdk/aws-logs:propertyNotSupported\",\n      Annotations.of(this).addWarning(\n        `The LogGroupClass property is not supported in the following regions: ${logGroupClassUnsupportedRegions}`,\n      );\n    }\n\n    this.resource = new cloudwatchLogGroup.CloudwatchLogGroup(\n      this,\n      \"Resource\",\n      {\n        name,\n        logGroupClass,\n        retentionInDays,\n        skipDestroy,\n        kmsKeyId: props.encryptionKey?.keyArn,\n      },\n    );\n\n    // https://registry.terraform.io/providers/hashicorp/aws/5.82.1/docs/resources/cloudwatch_log_group#attribute-reference\n    // terraform-provider-aws drops the trailing ':*' from the ARN when returning it as an attribute\n    this.logGroupArn = `${this.resource.arn}:*`;\n    this.logGroupName = this.resource.name;\n    if (props.dataProtectionPolicy) {\n      props.dataProtectionPolicy?._bind(this);\n    }\n  }\n}\n\n/**\n * Properties for a new LogStream created from a LogGroup\n */\nexport interface StreamOptions {\n  /**\n   * The name of the log stream to create.\n   *\n   * The name must be unique within the log group.\n   *\n   * @default Automatically generated\n   */\n  readonly logStreamName?: string;\n}\n\n/**\n * Properties for a new SubscriptionFilter created from a LogGroup\n */\nexport interface SubscriptionFilterOptions {\n  /**\n   * The destination to send the filtered events to.\n   *\n   * For example, a Kinesis stream or a Lambda function.\n   */\n  readonly destination: ILogSubscriptionDestination;\n\n  /**\n   * Log events matching this pattern will be sent to the destination.\n   */\n  readonly filterPattern: IFilterPattern;\n\n  /**\n   * The name of the subscription filter.\n   *\n   * @default Automatically generated\n   */\n  readonly filterName?: string;\n\n  /**\n   * The method used to distribute log data to the destination.\n   * This property can only be used with KinesisDestination.\n   *\n   * @default Distribution.BY_LOG_STREAM\n   */\n  readonly distribution?: Distribution;\n}\n\n/**\n * Properties for a MetricFilter created from a LogGroup\n */\nexport interface MetricFilterOptions {\n  /**\n   * Pattern to search for log events.\n   */\n  readonly filterPattern: IFilterPattern;\n\n  /**\n   * The namespace of the metric to emit.\n   */\n  readonly metricNamespace: string;\n\n  /**\n   * The name of the metric to emit.\n   */\n  readonly metricName: string;\n\n  /**\n   * The value to emit for the metric.\n   *\n   * Can either be a literal number (typically \"1\"), or the name of a field in the structure\n   * to take the value from the matched event. If you are using a field value, the field\n   * value must have been matched using the pattern.\n   *\n   * If you want to specify a field from a matched JSON structure, use '$.fieldName',\n   * and make sure the field is in the pattern (if only as '$.fieldName = *').\n   *\n   * If you want to specify a field from a matched space-delimited structure,\n   * use '$fieldName'.\n   *\n   * @default \"1\"\n   */\n  readonly metricValue?: string;\n\n  /**\n   * The value to emit if the pattern does not match a particular event.\n   *\n   * @default No metric emitted.\n   */\n  readonly defaultValue?: number;\n\n  /**\n   * The fields to use as dimensions for the metric. One metric filter can include as many as three dimensions.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-logs-metricfilter-metrictransformation.html#cfn-logs-metricfilter-metrictransformation-dimensions\n   * @default - No dimensions attached to metrics.\n   */\n  readonly dimensions?: Record<string, string>;\n\n  /**\n   * The unit to assign to the metric.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-logs-metricfilter-metrictransformation.html#cfn-logs-metricfilter-metrictransformation-unit\n   * @default - No unit attached to metrics.\n   */\n  readonly unit?: Unit;\n\n  /**\n   * The name of the metric filter.\n   *\n   * @default - Cloudformation generated name.\n   */\n  readonly filterName?: string;\n}\n"]}

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

@@ -0,0 +1,91 @@
+import { Construct } from "constructs";
+import { ConcreteWidget } from "./widget";
+/**
+ * Types of view
+ */
+export declare enum LogQueryVisualizationType {
+    /**
+     * Table view
+     */
+    TABLE = "table",
+    /**
+     * Line view
+     */
+    LINE = "line",
+    /**
+     * Stacked area view
+     */
+    STACKEDAREA = "stackedarea",
+    /**
+     * Bar view
+     */
+    BAR = "bar",
+    /**
+     * Pie view
+     */
+    PIE = "pie"
+}
+/**
+ * Properties for a Query widget
+ */
+export interface LogQueryWidgetProps {
+    /**
+     * Title for the widget
+     *
+     * @default No title
+     */
+    readonly title?: string;
+    /**
+     * Names of log groups to query
+     */
+    readonly logGroupNames: string[];
+    /**
+     * Full query string for log insights
+     *
+     * Be sure to prepend every new line with a newline and pipe character
+     * (`\n|`).
+     *
+     * @default - Exactly one of `queryString`, `queryLines` is required.
+     */
+    readonly queryString?: string;
+    /**
+     * A sequence of lines to use to build the query
+     *
+     * The query will be built by joining the lines together using `\n|`.
+     *
+     * @default - Exactly one of `queryString`, `queryLines` is required.
+     */
+    readonly queryLines?: string[];
+    /**
+     * The region the metrics of this widget should be taken from
+     *
+     * @default Current region
+     */
+    readonly region?: string;
+    /**
+     * The type of view to use
+     *
+     * @default LogQueryVisualizationType.TABLE
+     */
+    readonly view?: LogQueryVisualizationType;
+    /**
+     * Width of the widget, in a grid of 24 units wide
+     *
+     * @default 6
+     */
+    readonly width?: number;
+    /**
+     * Height of the widget
+     *
+     * @default 6
+     */
+    readonly height?: number;
+}
+/**
+ * Display query results from Logs Insights
+ */
+export declare class LogQueryWidget extends ConcreteWidget {
+    private readonly props;
+    constructor(scope: Construct, props: LogQueryWidgetProps);
+    toJson(): any[];
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogQueryWidget = exports.LogQueryVisualizationType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const widget_1 = require("./widget");
+/**
+ * Types of view
+ */
+var LogQueryVisualizationType;
+(function (LogQueryVisualizationType) {
+    /**
+     * Table view
+     */
+    LogQueryVisualizationType["TABLE"] = "table";
+    /**
+     * Line view
+     */
+    LogQueryVisualizationType["LINE"] = "line";
+    /**
+     * Stacked area view
+     */
+    LogQueryVisualizationType["STACKEDAREA"] = "stackedarea";
+    /**
+     * Bar view
+     */
+    LogQueryVisualizationType["BAR"] = "bar";
+    /**
+     * Pie view
+     */
+    LogQueryVisualizationType["PIE"] = "pie";
+})(LogQueryVisualizationType || (exports.LogQueryVisualizationType = LogQueryVisualizationType = {}));
+/**
+ * Display query results from Logs Insights
+ */
+class LogQueryWidget extends widget_1.ConcreteWidget {
+    constructor(scope, props) {
+        super(scope, props.width || 6, props.height || 6);
+        this.props = props;
+        if (props.logGroupNames.length === 0) {
+            throw new Error("Specify at least one log group name.");
+        }
+        if (!!props.queryString === !!props.queryLines) {
+            throw new Error("Specify exactly one of 'queryString' and 'queryLines'");
+        }
+    }
+    toJson() {
+        const sources = this.props.logGroupNames
+            .map((l) => `SOURCE '${l}'`)
+            .join(" | ");
+        const query = this.props.queryLines
+            ? this.props.queryLines.join("\n| ")
+            : this.props.queryString;
+        const properties = {
+            view: this.props.view ? this.props.view : LogQueryVisualizationType.TABLE,
+            title: this.props.title,
+            region: this.props.region || this.stack.region,
+            query: `${sources} | ${query}`,
+        };
+        // adding stacked property in case of LINE or STACKEDAREA
+        if (this.props.view === LogQueryVisualizationType.LINE ||
+            this.props.view === LogQueryVisualizationType.STACKEDAREA) {
+            // assign the right native view value. both types share the same value
+            (properties.view = "timeSeries"),
+                (properties.stacked =
+                    this.props.view === LogQueryVisualizationType.STACKEDAREA
+                        ? true
+                        : false);
+        }
+        return [
+            {
+                type: "log",
+                width: this.width,
+                height: this.height,
+                x: this.x,
+                y: this.y,
+                properties: properties,
+            },
+        ];
+    }
+}
+exports.LogQueryWidget = LogQueryWidget;
+_a = JSII_RTTI_SYMBOL_1;
+LogQueryWidget[_a] = { fqn: "terraconstructs.aws.cloudwatch.LogQueryWidget", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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