@liflig/cdk 2.18.5 → 2.18.6

package/lib/webapp/monitor.d.ts

@@ -0,0 +1,187 @@
+import * as cdk from "aws-cdk-lib";
+import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
+import * as cognito from "aws-cdk-lib/aws-cognito";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as rum from "aws-cdk-lib/aws-rum";
+import * as constructs from "constructs";
+type CwRumTelemetries = ("http" | "performance" | "errors")[];
+type EventsAlarm = {
+    /**
+     * An action to use for CloudWatch alarm state changes instead of the default action
+     */
+    action?: cloudwatch.IAlarmAction;
+    /**
+     * The threshold defined as the number of CloudWatch RUM events that determines if the alarm should trigger or not.
+     * @default 1000
+     */
+    threshold?: number;
+    /**
+     * @default 1
+     */
+    evaluationPeriods?: number;
+    /**
+     * @default cdk.Duration.minutes(1)
+     */
+    period?: cdk.Duration;
+    /**
+     * @default false
+     */
+    enableOkAlarm?: boolean;
+};
+type ErrorsAlarm = {
+    /**
+     * An action to use for CloudWatch alarm state changes instead of the default action
+     */
+    action?: cloudwatch.IAlarmAction;
+    /**
+     * The threshold defined as the number of JavaScript errors recorded by CloudWatch RUM that determines if the alarm should trigger or not.
+     * @default 0
+     */
+    threshold?: number;
+    /**
+     * @default 1
+     */
+    evaluationPeriods?: number;
+    /**
+     * @default cdk.Duration.minutes(1)
+     */
+    period?: cdk.Duration;
+    /**
+     * @default false
+     */
+    enableOkAlarms: boolean;
+};
+interface WebappMonitorProps {
+    /**
+     * The name of the CloudWatch RUM App Monitor.
+     *
+     * NOTE: This name needs to be unique within a given AWS region.
+     */
+    appMonitorName: string;
+    /**
+     * The domain the web application to monitor is served on.
+     *
+     * Only web applications served on this domain can publish data to CloudWatch RUM.
+     */
+    webappDomainName: string;
+    /**
+     * Which telemetries to allow CloudWatch RUM to collect.
+     *
+     * Currently these telemetries are supported:
+     * - "http" report the http fetch calles made by browser to CW RUM
+     * - "errors" report the js errors which occur, passed via rumConfig.recordError
+     * - "performance" report the app performance
+     *
+     * @default: ["errors", "http", "performance"]
+     */
+    telemetries?: CwRumTelemetries;
+    /**
+     * The default CloudWatch alarm action to use.
+     *
+     * By default, an alarm is created for a high number of events being sent to CloudWatch RUM. This alarm action is used for the default alarm,
+     * and for other alarms if no other action is explicitly set when configuring or enabling alarms through this construct.
+     *
+     */
+    defaultAlarmAction: cloudwatch.IAlarmAction;
+    /**
+     * Allow CloudWatch RUM to record custom events.
+     *
+     * These events need to be defined in and sent from your web application.
+     *
+     * @default false
+     */
+    enableXRay?: boolean;
+    /**
+     * Allow CloudWatch RUM to use cookies.
+     *
+     * CloudWatch RUM does not require cookies in order to record errors, but some features require cookies to be enabled.
+     * @default false
+     */
+    enableCustomEvents?: boolean;
+    /**
+     * Allow CloudWatch RUM to use cookies.
+     *
+     * CloudWatch RUM does not require cookies in order to record errors, but some features require cookies to be enabled.
+     *
+     * See: https://aws.amazon.com/blogs/mt/how-and-when-to-enable-session-cookies-with-amazon-cloudwatch-rum/
+     *
+     * NOTE: You'll likely need to introduce a cookie consent popup in your web application
+     * before enabling cookies in your client-side configuration.
+     *
+     * @default true
+     */
+    allowCookies?: boolean;
+    /**
+     * The rate of client-side CloudWatch RUM sessions to sample.
+     *
+     * Values are between 0 and 1, where 1 is 100% of sessions.
+     *
+     * NOTE: You'll likely want to set this to a number below 1 in production environments with
+     * a lot of traffic.
+     *
+     * @default 1
+     */
+    sessionSampleRate?: number;
+    /**
+     *
+     * Whether to store a copy of CloudWatch RUM events in CloudWatch Logs.
+     *
+     * Enabling this can improve the ergonomics of finding relevant CloudWatch RUM events compared to
+     * using the CloudWatch RUM console as it makes it possible to search using CloudWatch Logs Insights etc.
+     *
+     * @default false
+     */
+    exportLogs?: boolean;
+    /**
+     * Override top-level properties for the rum.CfnAppMonitor construct
+     *
+     * @default - no overrides are used.
+     */
+    overrideAppMonitorProps?: Partial<rum.CfnAppMonitorProps>;
+    /**
+     * Override App Monitor configuration properties for the rum.CfnAppMonitor construct
+     *
+     * @default - no overrides are used.
+     */
+    overrideAppMonitorConfiguration?: Partial<rum.CfnAppMonitor.AppMonitorConfigurationProperty>;
+}
+/**
+ *  A construct for creating a CloudWatch Real User Monitoring (RUM) App Monitor.
+ *
+ * An app monitor allows you to centrally collect and view client-side data (JavaScript and HTTP errors, performance metrics, etc.)
+ * recorded from a web application.
+ *
+ * NOTE: You'll need to add a JavaScript snippet to your web application and configure CloudWatch RUM using
+ * AWS's client-side SDK after deploying the construct to enable your web application to start collecting data.
+ * The App Monitor controls which CloudWatch RUM functionality the web application can use, and in order to
+ * leverage given functionality you'll need to configure it both in the App Monitor as well as in the
+ * configuration of the client-side SDK used by your web application.
+ *
+ */
+export declare class WebappMonitor extends constructs.Construct {
+    readonly identityPool: cognito.CfnIdentityPool;
+    readonly guestRole: iam.IRole;
+    readonly appMonitor: rum.CfnAppMonitor;
+    private readonly _webappDomainName;
+    private readonly _defaultAlarmAction;
+    private _eventsAlarm;
+    private _eventsAlarmId;
+    constructor(scope: constructs.Construct, id: string, props: WebappMonitorProps);
+    /**
+     *
+     * Configure an alarm used to notify on an unexpectedly high number of CloudWatch RUM events being recorded.
+     *
+     * This alarm is required when using this construct.
+     *
+     * @default - an alarm is created with sane defaults.
+     *
+     */
+    configureEventsAlarm(props?: EventsAlarm): void;
+    private _createEventsAlarm;
+    /**
+     * Add an alarm that alerts on JavaScript errors
+     * sent to CloudWatch RUM.
+     */
+    addErrorsAlarm(props?: ErrorsAlarm): void;
+}
+export {};

package/lib/webapp/monitor.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebappMonitor = void 0;
+const cdk = require("aws-cdk-lib");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const cognito = require("aws-cdk-lib/aws-cognito");
+const iam = require("aws-cdk-lib/aws-iam");
+const rum = require("aws-cdk-lib/aws-rum");
+const constructs = require("constructs");
+/**
+ *  A construct for creating a CloudWatch Real User Monitoring (RUM) App Monitor.
+ *
+ * An app monitor allows you to centrally collect and view client-side data (JavaScript and HTTP errors, performance metrics, etc.)
+ * recorded from a web application.
+ *
+ * NOTE: You'll need to add a JavaScript snippet to your web application and configure CloudWatch RUM using
+ * AWS's client-side SDK after deploying the construct to enable your web application to start collecting data.
+ * The App Monitor controls which CloudWatch RUM functionality the web application can use, and in order to
+ * leverage given functionality you'll need to configure it both in the App Monitor as well as in the
+ * configuration of the client-side SDK used by your web application.
+ *
+ */
+class WebappMonitor extends constructs.Construct {
+    constructor(scope, id, props) {
+        var _a, _b, _c, _d, _e;
+        super(scope, id);
+        this._eventsAlarmId = "EventsAlarm";
+        if (props.sessionSampleRate &&
+            (props.sessionSampleRate < 0 || props.sessionSampleRate > 1)) {
+            throw new Error("sessionSampleRate needs to be a number between 0 and 1");
+        }
+        this._webappDomainName = props.webappDomainName;
+        const appMonitorName = props.appMonitorName;
+        this.identityPool = new cognito.CfnIdentityPool(this, "RumIdentityPool", {
+            allowUnauthenticatedIdentities: true,
+        });
+        this.guestRole = new iam.Role(this, "RumRole", {
+            assumedBy: new iam.WebIdentityPrincipal("cognito-identity.amazonaws.com", {
+                StringEquals: {
+                    "cognito-identity.amazonaws.com:aud": this.identityPool.ref,
+                },
+                "ForAnyValue:StringEquals": {
+                    "cognito-identity.amazonaws.com:amr": "unauthenticated",
+                },
+            }),
+            inlinePolicies: {
+                "allow-rum": new iam.PolicyDocument({
+                    statements: [
+                        new iam.PolicyStatement({
+                            actions: ["rum:PutRumEvents"],
+                            resources: [
+                                cdk.Stack.of(this).formatArn({
+                                    service: "rum",
+                                    resource: "appmonitor",
+                                    resourceName: appMonitorName,
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            },
+        });
+        // attach role to identity pool
+        new cognito.CfnIdentityPoolRoleAttachment(this, "RoleAttachment", {
+            identityPoolId: this.identityPool.ref,
+            roles: {
+                unauthenticated: this.guestRole.roleArn,
+            },
+        });
+        this.appMonitor = new rum.CfnAppMonitor(this, "AppMonitor", {
+            name: appMonitorName,
+            domain: props.webappDomainName,
+            cwLogEnabled: (_a = props.exportLogs) !== null && _a !== void 0 ? _a : false,
+            appMonitorConfiguration: {
+                enableXRay: (_b = props.enableXRay) !== null && _b !== void 0 ? _b : false,
+                allowCookies: (_c = props.allowCookies) !== null && _c !== void 0 ? _c : true,
+                telemetries: (_d = props.telemetries) !== null && _d !== void 0 ? _d : ["errors", "http", "performance"],
+                sessionSampleRate: (_e = props.sessionSampleRate) !== null && _e !== void 0 ? _e : 1,
+                identityPoolId: this.identityPool.ref,
+                guestRoleArn: this.guestRole.roleArn,
+                ...props.overrideAppMonitorConfiguration,
+            },
+            customEvents: {
+                status: props.enableCustomEvents ? "ENABLED" : "DISABLED",
+            },
+            ...props.overrideAppMonitorProps,
+        });
+        this._defaultAlarmAction = props.defaultAlarmAction;
+        this._eventsAlarm = this._createEventsAlarm();
+    }
+    /**
+     *
+     * Configure an alarm used to notify on an unexpectedly high number of CloudWatch RUM events being recorded.
+     *
+     * This alarm is required when using this construct.
+     *
+     * @default - an alarm is created with sane defaults.
+     *
+     */
+    configureEventsAlarm(props) {
+        this.node.tryRemoveChild(this._eventsAlarmId);
+        this._eventsAlarm = this._createEventsAlarm(props);
+    }
+    _createEventsAlarm(props) {
+        var _a, _b, _c, _d, _e, _f;
+        const eventsAlarm = new cloudwatch.Metric({
+            metricName: "RumEventPayloadSize",
+            namespace: "AWS/RUM",
+            statistic: cloudwatch.Stats.SAMPLE_COUNT,
+            period: (_a = props === null || props === void 0 ? void 0 : props.period) !== null && _a !== void 0 ? _a : cdk.Duration.seconds(60),
+            dimensionsMap: {
+                application_name: this.appMonitor.name,
+            },
+        }).createAlarm(this, this._eventsAlarmId, {
+            alarmDescription: `A high number of events are being sent to CloudWatch RUM for app monitor '${this.appMonitor.name}'. This may lead to high costs, so you'll likely want to investigate this.`,
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: (_b = props === null || props === void 0 ? void 0 : props.threshold) !== null && _b !== void 0 ? _b : 1000,
+            evaluationPeriods: (_c = props === null || props === void 0 ? void 0 : props.evaluationPeriods) !== null && _c !== void 0 ? _c : 1,
+            treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+        });
+        // These alarms are mandatory as costs should be mandator to monitor
+        eventsAlarm.addAlarmAction((_d = props === null || props === void 0 ? void 0 : props.action) !== null && _d !== void 0 ? _d : this._defaultAlarmAction);
+        if ((_e = props === null || props === void 0 ? void 0 : props.enableOkAlarm) !== null && _e !== void 0 ? _e : false) {
+            eventsAlarm.addOkAction((_f = props === null || props === void 0 ? void 0 : props.action) !== null && _f !== void 0 ? _f : this._defaultAlarmAction);
+        }
+        return eventsAlarm;
+    }
+    /**
+     * Add an alarm that alerts on JavaScript errors
+     * sent to CloudWatch RUM.
+     */
+    addErrorsAlarm(props) {
+        var _a, _b, _c, _d, _e, _f;
+        const errorsAlarm = new cloudwatch.Metric({
+            metricName: "JsErrorCount",
+            namespace: "AWS/RUM",
+            statistic: cloudwatch.Stats.SAMPLE_COUNT,
+            period: (_a = props === null || props === void 0 ? void 0 : props.period) !== null && _a !== void 0 ? _a : cdk.Duration.seconds(60),
+            dimensionsMap: {
+                application_name: this.appMonitor.name,
+            },
+        }).createAlarm(this, "RumJsErrorsAlarm", {
+            alarmDescription: `CloudWatch RUM has recorded JavaScript errors for app monitor '${this.appMonitor.name}' on domain '${this._webappDomainName}'`,
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: (_b = props === null || props === void 0 ? void 0 : props.threshold) !== null && _b !== void 0 ? _b : 0,
+            evaluationPeriods: (_c = props === null || props === void 0 ? void 0 : props.evaluationPeriods) !== null && _c !== void 0 ? _c : 1,
+            treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+        });
+        errorsAlarm.addAlarmAction((_d = props === null || props === void 0 ? void 0 : props.action) !== null && _d !== void 0 ? _d : this._defaultAlarmAction);
+        if ((_e = props === null || props === void 0 ? void 0 : props.enableOkAlarms) !== null && _e !== void 0 ? _e : false) {
+            errorsAlarm.addOkAction((_f = props === null || props === void 0 ? void 0 : props.action) !== null && _f !== void 0 ? _f : this._defaultAlarmAction);
+        }
+    }
+}
+exports.WebappMonitor = WebappMonitor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monitor.js","sourceRoot":"","sources":["../../src/webapp/monitor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"aws-cdk-lib\"\nimport * as cloudwatch from \"aws-cdk-lib/aws-cloudwatch\"\nimport * as cognito from \"aws-cdk-lib/aws-cognito\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as rum from \"aws-cdk-lib/aws-rum\"\nimport * as constructs from \"constructs\"\n\ntype CwRumTelemetries = (\"http\" | \"performance\" | \"errors\")[]\n\ntype EventsAlarm = {\n  /**\n   * An action to use for CloudWatch alarm state changes instead of the default action\n   */\n  action?: cloudwatch.IAlarmAction\n  /**\n   * The threshold defined as the number of CloudWatch RUM events that determines if the alarm should trigger or not.\n   * @default 1000\n   */\n  threshold?: number\n  /**\n   * @default 1\n   */\n  evaluationPeriods?: number\n  /**\n   * @default cdk.Duration.minutes(1)\n   */\n  period?: cdk.Duration\n  /**\n   * @default false\n   */\n  enableOkAlarm?: boolean\n}\n\ntype ErrorsAlarm = {\n  /**\n   * An action to use for CloudWatch alarm state changes instead of the default action\n   */\n  action?: cloudwatch.IAlarmAction\n  /**\n   * The threshold defined as the number of JavaScript errors recorded by CloudWatch RUM that determines if the alarm should trigger or not.\n   * @default 0\n   */\n  threshold?: number\n  /**\n   * @default 1\n   */\n  evaluationPeriods?: number\n  /**\n   * @default cdk.Duration.minutes(1)\n   */\n  period?: cdk.Duration\n  /**\n   * @default false\n   */\n  enableOkAlarms: boolean\n}\n\ninterface WebappMonitorProps {\n  /**\n   * The name of the CloudWatch RUM App Monitor.\n   *\n   * NOTE: This name needs to be unique within a given AWS region.\n   */\n  appMonitorName: string\n  /**\n   * The domain the web application to monitor is served on.\n   *\n   * Only web applications served on this domain can publish data to CloudWatch RUM.\n   */\n  webappDomainName: string\n  /**\n   * Which telemetries to allow CloudWatch RUM to collect.\n   *\n   * Currently these telemetries are supported:\n   * - \"http\" report the http fetch calles made by browser to CW RUM\n   * - \"errors\" report the js errors which occur, passed via rumConfig.recordError\n   * - \"performance\" report the app performance\n   *\n   * @default: [\"errors\", \"http\", \"performance\"]\n   */\n  telemetries?: CwRumTelemetries\n  /**\n   * The default CloudWatch alarm action to use.\n   *\n   * By default, an alarm is created for a high number of events being sent to CloudWatch RUM. This alarm action is used for the default alarm,\n   * and for other alarms if no other action is explicitly set when configuring or enabling alarms through this construct.\n   *\n   */\n  defaultAlarmAction: cloudwatch.IAlarmAction\n  /**\n   * Allow CloudWatch RUM to record custom events.\n   *\n   * These events need to be defined in and sent from your web application.\n   *\n   * @default false\n   */\n  enableXRay?: boolean\n  /**\n   * Allow CloudWatch RUM to use cookies.\n   *\n   * CloudWatch RUM does not require cookies in order to record errors, but some features require cookies to be enabled.\n   * @default false\n   */\n  enableCustomEvents?: boolean\n  /**\n   * Allow CloudWatch RUM to use cookies.\n   *\n   * CloudWatch RUM does not require cookies in order to record errors, but some features require cookies to be enabled.\n   *\n   * See: https://aws.amazon.com/blogs/mt/how-and-when-to-enable-session-cookies-with-amazon-cloudwatch-rum/\n   *\n   * NOTE: You'll likely need to introduce a cookie consent popup in your web application\n   * before enabling cookies in your client-side configuration.\n   *\n   * @default true\n   */\n  allowCookies?: boolean\n  /**\n   * The rate of client-side CloudWatch RUM sessions to sample.\n   *\n   * Values are between 0 and 1, where 1 is 100% of sessions.\n   *\n   * NOTE: You'll likely want to set this to a number below 1 in production environments with\n   * a lot of traffic.\n   *\n   * @default 1\n   */\n  sessionSampleRate?: number\n  /**\n   *\n   * Whether to store a copy of CloudWatch RUM events in CloudWatch Logs.\n   *\n   * Enabling this can improve the ergonomics of finding relevant CloudWatch RUM events compared to\n   * using the CloudWatch RUM console as it makes it possible to search using CloudWatch Logs Insights etc.\n   *\n   * @default false\n   */\n  exportLogs?: boolean\n  /**\n   * Override top-level properties for the rum.CfnAppMonitor construct\n   *\n   * @default - no overrides are used.\n   */\n  overrideAppMonitorProps?: Partial<rum.CfnAppMonitorProps>\n  /**\n   * Override App Monitor configuration properties for the rum.CfnAppMonitor construct\n   *\n   * @default - no overrides are used.\n   */\n  overrideAppMonitorConfiguration?: Partial<rum.CfnAppMonitor.AppMonitorConfigurationProperty>\n}\n\n/**\n *  A construct for creating a CloudWatch Real User Monitoring (RUM) App Monitor.\n *\n * An app monitor allows you to centrally collect and view client-side data (JavaScript and HTTP errors, performance metrics, etc.)\n * recorded from a web application.\n *\n * NOTE: You'll need to add a JavaScript snippet to your web application and configure CloudWatch RUM using\n * AWS's client-side SDK after deploying the construct to enable your web application to start collecting data.\n * The App Monitor controls which CloudWatch RUM functionality the web application can use, and in order to\n * leverage given functionality you'll need to configure it both in the App Monitor as well as in the\n * configuration of the client-side SDK used by your web application.\n *\n */\nexport class WebappMonitor extends constructs.Construct {\n  readonly identityPool: cognito.CfnIdentityPool\n  readonly guestRole: iam.IRole\n  readonly appMonitor: rum.CfnAppMonitor\n  private readonly _webappDomainName: string\n\n  private readonly _defaultAlarmAction: cloudwatch.IAlarmAction\n\n  private _eventsAlarm: cloudwatch.IAlarm\n  private _eventsAlarmId = \"EventsAlarm\"\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: WebappMonitorProps,\n  ) {\n    super(scope, id)\n\n    if (\n      props.sessionSampleRate &&\n      (props.sessionSampleRate < 0 || props.sessionSampleRate > 1)\n    ) {\n      throw new Error(\"sessionSampleRate needs to be a number between 0 and 1\")\n    }\n\n    this._webappDomainName = props.webappDomainName\n\n    const appMonitorName = props.appMonitorName\n\n    this.identityPool = new cognito.CfnIdentityPool(this, \"RumIdentityPool\", {\n      allowUnauthenticatedIdentities: true,\n    })\n\n    this.guestRole = new iam.Role(this, \"RumRole\", {\n      assumedBy: new iam.WebIdentityPrincipal(\n        \"cognito-identity.amazonaws.com\",\n        {\n          StringEquals: {\n            \"cognito-identity.amazonaws.com:aud\": this.identityPool.ref,\n          },\n          \"ForAnyValue:StringEquals\": {\n            \"cognito-identity.amazonaws.com:amr\": \"unauthenticated\",\n          },\n        },\n      ),\n      inlinePolicies: {\n        \"allow-rum\": new iam.PolicyDocument({\n          statements: [\n            new iam.PolicyStatement({\n              actions: [\"rum:PutRumEvents\"],\n              resources: [\n                cdk.Stack.of(this).formatArn({\n                  service: \"rum\",\n                  resource: \"appmonitor\",\n                  resourceName: appMonitorName,\n                }),\n              ],\n            }),\n          ],\n        }),\n      },\n    })\n\n    // attach role to identity pool\n    new cognito.CfnIdentityPoolRoleAttachment(this, \"RoleAttachment\", {\n      identityPoolId: this.identityPool.ref,\n      roles: {\n        unauthenticated: this.guestRole.roleArn,\n      },\n    })\n\n    this.appMonitor = new rum.CfnAppMonitor(this, \"AppMonitor\", {\n      name: appMonitorName,\n      domain: props.webappDomainName,\n      cwLogEnabled: props.exportLogs ?? false,\n      appMonitorConfiguration: {\n        enableXRay: props.enableXRay ?? false,\n        allowCookies: props.allowCookies ?? true,\n        telemetries: props.telemetries ?? [\"errors\", \"http\", \"performance\"],\n        sessionSampleRate: props.sessionSampleRate ?? 1,\n        identityPoolId: this.identityPool.ref,\n        guestRoleArn: this.guestRole.roleArn,\n        ...props.overrideAppMonitorConfiguration,\n      },\n      customEvents: {\n        status: props.enableCustomEvents ? \"ENABLED\" : \"DISABLED\",\n      },\n      ...props.overrideAppMonitorProps,\n    })\n\n    this._defaultAlarmAction = props.defaultAlarmAction\n    this._eventsAlarm = this._createEventsAlarm()\n  }\n\n  /**\n   *\n   * Configure an alarm used to notify on an unexpectedly high number of CloudWatch RUM events being recorded.\n   *\n   * This alarm is required when using this construct.\n   *\n   * @default - an alarm is created with sane defaults.\n   *\n   */\n  configureEventsAlarm(props?: EventsAlarm) {\n    this.node.tryRemoveChild(this._eventsAlarmId)\n    this._eventsAlarm = this._createEventsAlarm(props)\n  }\n\n  private _createEventsAlarm(props?: EventsAlarm): cloudwatch.IAlarm {\n    const eventsAlarm = new cloudwatch.Metric({\n      metricName: \"RumEventPayloadSize\",\n      namespace: \"AWS/RUM\",\n      statistic: cloudwatch.Stats.SAMPLE_COUNT,\n      period: props?.period ?? cdk.Duration.seconds(60),\n      dimensionsMap: {\n        application_name: this.appMonitor.name,\n      },\n    }).createAlarm(this, this._eventsAlarmId, {\n      alarmDescription: `A high number of events are being sent to CloudWatch RUM for app monitor '${this.appMonitor.name}'. This may lead to high costs, so you'll likely want to investigate this.`,\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      threshold: props?.threshold ?? 1000,\n      evaluationPeriods: props?.evaluationPeriods ?? 1,\n      treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n    })\n\n    // These alarms are mandatory as costs should be mandator to monitor\n    eventsAlarm.addAlarmAction(props?.action ?? this._defaultAlarmAction)\n    if (props?.enableOkAlarm ?? false) {\n      eventsAlarm.addOkAction(props?.action ?? this._defaultAlarmAction)\n    }\n\n    return eventsAlarm\n  }\n\n  /**\n   * Add an alarm that alerts on JavaScript errors\n   * sent to CloudWatch RUM.\n   */\n  addErrorsAlarm(props?: ErrorsAlarm) {\n    const errorsAlarm = new cloudwatch.Metric({\n      metricName: \"JsErrorCount\",\n      namespace: \"AWS/RUM\",\n      statistic: cloudwatch.Stats.SAMPLE_COUNT,\n      period: props?.period ?? cdk.Duration.seconds(60),\n      dimensionsMap: {\n        application_name: this.appMonitor.name,\n      },\n    }).createAlarm(this, \"RumJsErrorsAlarm\", {\n      alarmDescription: `CloudWatch RUM has recorded JavaScript errors for app monitor '${this.appMonitor.name}' on domain '${this._webappDomainName}'`,\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      threshold: props?.threshold ?? 0,\n      evaluationPeriods: props?.evaluationPeriods ?? 1,\n      treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n    })\n\n    errorsAlarm.addAlarmAction(props?.action ?? this._defaultAlarmAction)\n\n    if (props?.enableOkAlarms ?? false) {\n      errorsAlarm.addOkAction(props?.action ?? this._defaultAlarmAction)\n    }\n  }\n}\n"]}

package/lib/webapp/security-headers.d.ts

@@ -0,0 +1,38 @@
+import * as constructs from "constructs";
+import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
+export type WebappSecurityHeadersProps = Partial<cloudfront.ResponseSecurityHeadersBehavior & {
+    contentSecurityPolicy?: cloudfront.ResponseSecurityHeadersBehavior["contentSecurityPolicy"] & {
+        /**
+         * Whether to only monitor the effects of the content security policy without actually blocking anything.
+         * @default false
+         */
+        reportOnly?: boolean;
+    };
+}>;
+export interface ContentSecurityPolicyHeader {
+    baseUri?: string;
+    childSrc?: string;
+    defaultSrc?: string;
+    fontSrc?: string;
+    frameSrc?: string;
+    formAction?: string;
+    frameAncestors?: string;
+    imgSrc?: string;
+    manifestSrc?: string;
+    mediaSrc?: string;
+    objectSrc?: string;
+    scriptSrc?: string;
+    styleSrc?: string;
+    connectSrc?: string;
+}
+/**
+ * Helper function that generates a string containing a Content Security Policy that can be
+ * used in a security header.
+ *
+ * NOTE: The string can be further extended using string concatenation for directives that aren't currently supported by the function.
+ */
+export declare function generateContentSecurityPolicyHeader(headerOptions?: ContentSecurityPolicyHeader): string;
+export declare class WebappSecurityHeaders extends constructs.Construct {
+    readonly responseHeadersPolicy: cloudfront.ResponseHeadersPolicy;
+    constructor(scope: constructs.Construct, id: string, props: WebappSecurityHeadersProps);
+}

package/lib/webapp/security-headers.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebappSecurityHeaders = exports.generateContentSecurityPolicyHeader = void 0;
+const cdk = require("aws-cdk-lib");
+const constructs = require("constructs");
+const cloudfront = require("aws-cdk-lib/aws-cloudfront");
+function validateCspParam(param) {
+    if (param.indexOf('"') !== -1) {
+        throw Error('CSP override contains invalid character "');
+    }
+    if (param.indexOf(";") !== -1) {
+        throw Error("CSP override contains invalid character ;");
+    }
+    if (param.indexOf("\\") !== -1) {
+        throw Error("CSP override contains invalid character \\");
+    }
+    return param;
+}
+/* Replace all whitespace in a string with a single space */
+function trim(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+/**
+ * Helper function that generates a string containing a Content Security Policy that can be
+ * used in a security header.
+ *
+ * NOTE: The string can be further extended using string concatenation for directives that aren't currently supported by the function.
+ */
+function generateContentSecurityPolicyHeader(headerOptions) {
+    const defaultValues = {
+        baseUri: "'self'",
+        childSrc: "'self'",
+        connectSrc: "'self' https:",
+        defaultSrc: "'none'",
+        fontSrc: "'self'",
+        formAction: "'none'",
+        frameAncestors: "'none'",
+        frameSrc: "'self'",
+        imgSrc: "'self' data:",
+        manifestSrc: "'self'",
+        mediaSrc: "'self'",
+        objectSrc: "'none'",
+        scriptSrc: "'self'",
+        styleSrc: "'self'",
+    };
+    const options = {
+        ...defaultValues,
+        ...headerOptions,
+    };
+    Object.values(options).forEach((v) => typeof v === "string" && validateCspParam(v));
+    let headerValue = "";
+    headerValue += `base-uri ${trim(options.baseUri)};`;
+    headerValue += `child-src ${trim(options.childSrc)};`;
+    headerValue += `connect-src ${trim(options.connectSrc)};`;
+    headerValue += `default-src ${trim(options.defaultSrc)};`;
+    headerValue += `font-src ${trim(options.fontSrc)};`;
+    headerValue += `frame-src ${trim(options.frameSrc)};`;
+    headerValue += `form-action ${trim(options.formAction)};`;
+    headerValue += `frame-ancestors ${trim(options.frameAncestors)};`;
+    headerValue += `img-src ${trim(options.imgSrc)};`;
+    headerValue += `manifest-src ${trim(options.manifestSrc)};`;
+    headerValue += `media-src ${trim(options.mediaSrc)};`;
+    headerValue += `object-src ${trim(options.objectSrc)};`;
+    headerValue += `script-src ${trim(options.scriptSrc)};`;
+    headerValue += `style-src ${trim(options.styleSrc)}`;
+    return trim(headerValue);
+}
+exports.generateContentSecurityPolicyHeader = generateContentSecurityPolicyHeader;
+class WebappSecurityHeaders extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { contentSecurityPolicy: contentSecurityPolicyOverride, ...overrides } = props;
+        const contentSecurityPolicyCustomHeader = contentSecurityPolicyOverride || {
+            reportOnly: false,
+            contentSecurityPolicy: generateContentSecurityPolicyHeader(),
+            override: true,
+        };
+        const defaultValues = {
+            contentTypeOptions: {
+                override: true,
+            },
+            referrerPolicy: {
+                override: true,
+                referrerPolicy: cloudfront.HeadersReferrerPolicy.SAME_ORIGIN,
+            },
+            frameOptions: {
+                frameOption: cloudfront.HeadersFrameOption.DENY,
+                override: true,
+            },
+            strictTransportSecurity: {
+                override: true,
+                accessControlMaxAge: cdk.Duration.days(182.5),
+                includeSubdomains: false,
+                preload: false,
+            },
+            xssProtection: {
+                override: true,
+                protection: true,
+                modeBlock: true,
+            },
+        };
+        this.responseHeadersPolicy = new cloudfront.ResponseHeadersPolicy(this, "ResponseHeadersPolicy", {
+            securityHeadersBehavior: {
+                ...defaultValues,
+                ...overrides,
+                ...(!contentSecurityPolicyCustomHeader.reportOnly && {
+                    contentSecurityPolicy: {
+                        contentSecurityPolicy: contentSecurityPolicyCustomHeader.contentSecurityPolicy,
+                        override: contentSecurityPolicyCustomHeader.override,
+                    },
+                }),
+            },
+            ...(contentSecurityPolicyCustomHeader.reportOnly && {
+                customHeadersBehavior: {
+                    // Report only is not supported by securityHeadersBehavior in AWS and must be defined as custom header
+                    customHeaders: [
+                        {
+                            header: "Content-Security-Policy-Report-Only",
+                            value: contentSecurityPolicyCustomHeader.contentSecurityPolicy,
+                            override: contentSecurityPolicyCustomHeader.override,
+                        },
+                    ],
+                },
+            }),
+        });
+    }
+}
+exports.WebappSecurityHeaders = WebappSecurityHeaders;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-headers.js","sourceRoot":"","sources":["../../src/webapp/security-headers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"aws-cdk-lib\"\nimport * as constructs from \"constructs\"\nimport * as cloudfront from \"aws-cdk-lib/aws-cloudfront\"\n\nexport type WebappSecurityHeadersProps = Partial<\n  cloudfront.ResponseSecurityHeadersBehavior & {\n    contentSecurityPolicy?: cloudfront.ResponseSecurityHeadersBehavior[\"contentSecurityPolicy\"] & {\n      /**\n       * Whether to only monitor the effects of the content security policy without actually blocking anything.\n       * @default false\n       */\n      reportOnly?: boolean\n    }\n  }\n>\n\nexport interface ContentSecurityPolicyHeader {\n  baseUri?: string\n  childSrc?: string\n  defaultSrc?: string\n  fontSrc?: string\n  frameSrc?: string\n  formAction?: string\n  frameAncestors?: string\n  imgSrc?: string\n  manifestSrc?: string\n  mediaSrc?: string\n  objectSrc?: string\n  scriptSrc?: string\n  styleSrc?: string\n  connectSrc?: string\n}\n\nfunction validateCspParam(param: string): string {\n  if (param.indexOf('\"') !== -1) {\n    throw Error('CSP override contains invalid character \"')\n  }\n\n  if (param.indexOf(\";\") !== -1) {\n    throw Error(\"CSP override contains invalid character ;\")\n  }\n\n  if (param.indexOf(\"\\\\\") !== -1) {\n    throw Error(\"CSP override contains invalid character \\\\\")\n  }\n\n  return param\n}\n\n/* Replace all whitespace in a string with a single space */\nfunction trim(value: string): string {\n  return value.replace(/\\s+/g, \" \").trim()\n}\n\n/**\n * Helper function that generates a string containing a Content Security Policy that can be\n * used in a security header.\n *\n * NOTE: The string can be further extended using string concatenation for directives that aren't currently supported by the function.\n */\nexport function generateContentSecurityPolicyHeader(\n  headerOptions?: ContentSecurityPolicyHeader,\n) {\n  const defaultValues = {\n    baseUri: \"'self'\",\n    childSrc: \"'self'\",\n    connectSrc: \"'self' https:\",\n    defaultSrc: \"'none'\",\n    fontSrc: \"'self'\",\n    formAction: \"'none'\",\n    frameAncestors: \"'none'\",\n    frameSrc: \"'self'\",\n    imgSrc: \"'self' data:\",\n    manifestSrc: \"'self'\",\n    mediaSrc: \"'self'\",\n    objectSrc: \"'none'\",\n    scriptSrc: \"'self'\",\n    styleSrc: \"'self'\",\n  }\n\n  const options = {\n    ...defaultValues,\n    ...headerOptions,\n  }\n\n  Object.values(options).forEach(\n    (v) => typeof v === \"string\" && validateCspParam(v),\n  )\n\n  let headerValue = \"\"\n  headerValue += `base-uri ${trim(options.baseUri)};`\n  headerValue += `child-src ${trim(options.childSrc)};`\n  headerValue += `connect-src ${trim(options.connectSrc)};`\n  headerValue += `default-src ${trim(options.defaultSrc)};`\n  headerValue += `font-src ${trim(options.fontSrc)};`\n  headerValue += `frame-src ${trim(options.frameSrc)};`\n  headerValue += `form-action ${trim(options.formAction)};`\n  headerValue += `frame-ancestors ${trim(options.frameAncestors)};`\n  headerValue += `img-src ${trim(options.imgSrc)};`\n  headerValue += `manifest-src ${trim(options.manifestSrc)};`\n  headerValue += `media-src ${trim(options.mediaSrc)};`\n  headerValue += `object-src ${trim(options.objectSrc)};`\n  headerValue += `script-src ${trim(options.scriptSrc)};`\n  headerValue += `style-src ${trim(options.styleSrc)}`\n\n  return trim(headerValue)\n}\nexport class WebappSecurityHeaders extends constructs.Construct {\n  public readonly responseHeadersPolicy: cloudfront.ResponseHeadersPolicy\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: WebappSecurityHeadersProps,\n  ) {\n    super(scope, id)\n\n    const {\n      contentSecurityPolicy: contentSecurityPolicyOverride,\n      ...overrides\n    } = props\n\n    const contentSecurityPolicyCustomHeader = contentSecurityPolicyOverride || {\n      reportOnly: false,\n      contentSecurityPolicy: generateContentSecurityPolicyHeader(),\n      override: true,\n    }\n\n    const defaultValues: Omit<\n      cloudfront.ResponseSecurityHeadersBehavior,\n      \"contentSecurityPolicy\"\n    > = {\n      contentTypeOptions: {\n        override: true,\n      },\n      referrerPolicy: {\n        override: true,\n        referrerPolicy: cloudfront.HeadersReferrerPolicy.SAME_ORIGIN,\n      },\n      frameOptions: {\n        frameOption: cloudfront.HeadersFrameOption.DENY,\n        override: true,\n      },\n      strictTransportSecurity: {\n        override: true,\n        accessControlMaxAge: cdk.Duration.days(182.5),\n        includeSubdomains: false,\n        preload: false,\n      },\n      xssProtection: {\n        override: true,\n        protection: true,\n        modeBlock: true,\n      },\n    }\n\n    this.responseHeadersPolicy = new cloudfront.ResponseHeadersPolicy(\n      this,\n      \"ResponseHeadersPolicy\",\n      {\n        securityHeadersBehavior: {\n          ...defaultValues,\n          ...overrides,\n          ...(!contentSecurityPolicyCustomHeader.reportOnly && {\n            contentSecurityPolicy: {\n              contentSecurityPolicy:\n                contentSecurityPolicyCustomHeader.contentSecurityPolicy,\n              override: contentSecurityPolicyCustomHeader.override,\n            },\n          }),\n        },\n        ...(contentSecurityPolicyCustomHeader.reportOnly && {\n          customHeadersBehavior: {\n            // Report only is not supported by securityHeadersBehavior in AWS and must be defined as custom header\n            customHeaders: [\n              {\n                header: \"Content-Security-Policy-Report-Only\",\n                value: contentSecurityPolicyCustomHeader.contentSecurityPolicy,\n                override: contentSecurityPolicyCustomHeader.override,\n              },\n            ],\n          },\n        }),\n      },\n    )\n  }\n}\n"]}