@ashishpandeyone/cdk-lambda-web-function 0.1.2 → 0.1.4

package/lib/web-function-deployment.d.ts

@@ -1,5 +1,49 @@
 import { Duration } from 'aws-cdk-lib';
 import type * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
+import type { ResolvedRollbackOptions } from './private/rollback';
+/**
+ * Alarms an endpoint creates on its own metrics to stop a canary or linear deployment.
+ *
+ * The endpoint creates one alarm per threshold in every region it serves from (metrics are published
+ * in the region that served the request, and an alarm can only watch metrics in its own region).
+ * Lambda Web Function metrics have no revision dimension, so the alarms watch the whole endpoint: while
+ * the new revision gets 10% of the traffic, its errors are about a tenth of the endpoint's.
+ */
+export interface WebFunctionRollbackOptions {
+    /**
+     * Roll back when more than this percent of the endpoint's requests get a 5XX response (0-100).
+     *
+     * 5XX includes the platform's 503s while an endpoint scales up for a sudden burst, not only your application's errors.
+     *
+     * @default - no server error alarm
+     */
+    readonly serverErrorRate?: number;
+    /**
+     * Roll back when more than this percent of the endpoint's requests get a 4XX response (0-100).
+     * Requests over `rateLimit` or `maxEnvironments` get 429, which counts here.
+     *
+     * @default - no client error alarm
+     */
+    readonly clientErrorRate?: number;
+    /**
+     * Periods with fewer requests than this don't count, so one failed request out of two doesn't roll back.
+     *
+     * @default 10
+     */
+    readonly minimumRequests?: number;
+    /**
+     * The period each rate is measured over (at least 1 minute, in whole minutes).
+     *
+     * @default Duration.minutes(1)
+     */
+    readonly period?: Duration;
+    /**
+     * How many consecutive periods must breach a threshold before the deployment rolls back.
+     *
+     * @default 2
+     */
+    readonly evaluationPeriods?: number;
+}
 /**
  * Options for a canary deployment.
  */
@@ -23,6 +67,13 @@ export interface WebFunctionCanaryDeploymentOptions {
      * @default - no alarms: traffic moves on a timer
      */
     readonly alarms?: cloudwatch.IAlarm[];
+    /**
+     * Alarms on the endpoint's own error rates, created by the endpoint in every region it serves from.
+     * They stop the deployment like `alarms` (both can be used together).
+     *
+     * @default - no endpoint alarms
+     */
+    readonly rollbackOn?: WebFunctionRollbackOptions;
 }
 /**
  * Options for a linear deployment.
@@ -46,6 +97,13 @@ export interface WebFunctionLinearDeploymentOptions {
      * @default - no alarms: traffic moves on a timer
      */
     readonly alarms?: cloudwatch.IAlarm[];
+    /**
+     * Alarms on the endpoint's own error rates, created by the endpoint in every region it serves from.
+     * They stop the deployment like `alarms` (both can be used together).
+     *
+     * @default - no endpoint alarms
+     */
+    readonly rollbackOn?: WebFunctionRollbackOptions;
 }
 /**
  * How an endpoint moves its traffic to a new revision.
@@ -79,6 +137,12 @@ export declare class WebFunctionDeployment {
     readonly _alarms: cloudwatch.IAlarm[];
     /** @internal */
     readonly _kind: string;
+    /**
+     * Thresholds for the alarms the endpoint creates, with defaults applied.
+     *
+     * @internal
+     */
+    readonly _rollbackOn?: ResolvedRollbackOptions;
     private constructor();
     /**
      * Whether traffic moves in steps (canary or linear) rather than all at once.

package/lib/web-function-deployment.js

@@ -11,12 +11,12 @@ const MAX_STEPS = 20;
  * How an endpoint moves its traffic to a new revision.
  */
 class WebFunctionDeployment {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionDeployment", version: "0.1.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionDeployment", version: "0.1.4" };
     /**
      * All traffic moves to the new revision at once, as soon as it's ready (the default).
      */
     static allAtOnce() {
-        return new WebFunctionDeployment('allAtOnce', [100], 0, []);
+        return new WebFunctionDeployment('allAtOnce', [100], 0, [], undefined);
     }
     /**
      * The new revision first gets `percent` of the traffic for `bake`, then all of it.
@@ -24,7 +24,7 @@ class WebFunctionDeployment {
     static canary(options) {
         const percent = wholePercent('canary', 'percent', options.percent, 1, 99);
         const bake = minutes('canary', 'bake', options.bake, MAX_TOTAL_WAIT_MINUTES);
-        return new WebFunctionDeployment('canary', [percent, 100], bake.toSeconds(), options.alarms ?? []);
+        return new WebFunctionDeployment('canary', [percent, 100], bake.toSeconds(), options.alarms ?? [], rollbackOn('canary', options.rollbackOn));
     }
     /**
      * The new revision gets `percent` more of the traffic every `interval` until it has all of it.
@@ -40,7 +40,7 @@ class WebFunctionDeployment {
         if (total > MAX_TOTAL_WAIT_MINUTES * 60) {
             throw new Error(`WebFunctionDeployment.linear: ${steps.length - 1} intervals of ${interval.toHumanString()} take ${total / 60} minutes; at most ${MAX_TOTAL_WAIT_MINUTES} are allowed`);
         }
-        return new WebFunctionDeployment('linear', steps, interval.toSeconds(), options.alarms ?? []);
+        return new WebFunctionDeployment('linear', steps, interval.toSeconds(), options.alarms ?? [], rollbackOn('linear', options.rollbackOn));
     }
     /**
      * The new revision's share of traffic at each step, in percent; the last is 100.
@@ -58,11 +58,18 @@ class WebFunctionDeployment {
     _alarms;
     /** @internal */
     _kind;
-    constructor(kind, steps, waitSeconds, alarms) {
+    /**
+     * Thresholds for the alarms the endpoint creates, with defaults applied.
+     *
+     * @internal
+     */
+    _rollbackOn;
+    constructor(kind, steps, waitSeconds, alarms, rollback) {
         this._kind = kind;
         this._steps = steps;
         this._waitSeconds = waitSeconds;
         this._alarms = alarms;
+        this._rollbackOn = rollback;
     }
     /**
      * Whether traffic moves in steps (canary or linear) rather than all at once.
@@ -87,4 +94,32 @@ function minutes(kind, name, value, maxMinutes) {
     }
     return aws_cdk_lib_1.Duration.seconds(seconds);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-function-deployment.js","sourceRoot":"","sources":["../src/web-function-deployment.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, Token } from 'aws-cdk-lib';\nimport type * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\n\n/** Longest total wait of a deployment: the deployment step must finish within CloudFormation's 1-hour custom resource limit. */\nconst MAX_TOTAL_WAIT_MINUTES = 45;\n/** Most traffic steps: each one also waits for the endpoint to update in every region. */\nconst MAX_STEPS = 20;\n\n/**\n * Options for a canary deployment.\n */\nexport interface WebFunctionCanaryDeploymentOptions {\n  /**\n   * The share of traffic, in whole percent (1-99), that the new revision gets first.\n   */\n  readonly percent: number;\n\n  /**\n   * How long the new revision serves `percent` before it gets all traffic (1-45 minutes).\n   * Make it longer than the time your alarms need to fire (period × evaluation periods).\n   */\n  readonly bake: Duration;\n\n  /**\n   * Alarms that stop the deployment: if one is in ALARM, the endpoint goes back to the previous\n   * revision and the deployment fails, so CloudFormation rolls the stack back.\n   *\n   * They're checked before traffic moves, during the bake, and once the new revision has all traffic.\n   * Use alarms in any region (by ARN), including composite alarms.\n   *\n   * @default - no alarms: traffic moves on a timer\n   */\n  readonly alarms?: cloudwatch.IAlarm[];\n}\n\n/**\n * Options for a linear deployment.\n */\nexport interface WebFunctionLinearDeploymentOptions {\n  /**\n   * The share of traffic, in whole percent (5-50), that moves to the new revision at each step.\n   */\n  readonly percent: number;\n\n  /**\n   * How long each step serves before the next one (at least 1 minute, and at most 45 minutes in total).\n   */\n  readonly interval: Duration;\n\n  /**\n   * Alarms that stop the deployment: if one is in ALARM, the endpoint goes back to the previous\n   * revision and the deployment fails, so CloudFormation rolls the stack back.\n   *\n   * They're checked before traffic moves, during every step, and once the new revision has all traffic.\n   * Use alarms in any region (by ARN), including composite alarms.\n   *\n   * @default - no alarms: traffic moves on a timer\n   */\n  readonly alarms?: cloudwatch.IAlarm[];\n}\n\n/**\n * How an endpoint moves its traffic to a new revision.\n */\nexport class WebFunctionDeployment {\n  /**\n   * All traffic moves to the new revision at once, as soon as it's ready (the default).\n   */\n  public static allAtOnce(): WebFunctionDeployment {\n    return new WebFunctionDeployment('allAtOnce', [100], 0, []);\n  }\n\n  /**\n   * The new revision first gets `percent` of the traffic for `bake`, then all of it.\n   */\n  public static canary(options: WebFunctionCanaryDeploymentOptions): WebFunctionDeployment {\n    const percent = wholePercent('canary', 'percent', options.percent, 1, 99);\n    const bake = minutes('canary', 'bake', options.bake, MAX_TOTAL_WAIT_MINUTES);\n    return new WebFunctionDeployment('canary', [percent, 100], bake.toSeconds(), options.alarms ?? []);\n  }\n\n  /**\n   * The new revision gets `percent` more of the traffic every `interval` until it has all of it.\n   */\n  public static linear(options: WebFunctionLinearDeploymentOptions): WebFunctionDeployment {\n    const percent = wholePercent('linear', 'percent', options.percent, 100 / MAX_STEPS, 50);\n    const interval = minutes('linear', 'interval', options.interval, MAX_TOTAL_WAIT_MINUTES);\n    const steps: number[] = [];\n    for (let p = percent; p < 100; p += percent) steps.push(p);\n    steps.push(100);\n    const total = interval.toSeconds() * (steps.length - 1);\n    if (total > MAX_TOTAL_WAIT_MINUTES * 60) {\n      throw new Error(`WebFunctionDeployment.linear: ${steps.length - 1} intervals of ${interval.toHumanString()} take ${total / 60} minutes; at most ${MAX_TOTAL_WAIT_MINUTES} are allowed`);\n    }\n    return new WebFunctionDeployment('linear', steps, interval.toSeconds(), options.alarms ?? []);\n  }\n\n  /**\n   * The new revision's share of traffic at each step, in percent; the last is 100.\n   *\n   * @internal\n   */\n  public readonly _steps: number[];\n\n  /**\n   * Seconds each step serves before the next.\n   *\n   * @internal\n   */\n  public readonly _waitSeconds: number;\n\n  /** @internal */\n  public readonly _alarms: cloudwatch.IAlarm[];\n\n  /** @internal */\n  public readonly _kind: string;\n\n  private constructor(kind: string, steps: number[], waitSeconds: number, alarms: cloudwatch.IAlarm[]) {\n    this._kind = kind;\n    this._steps = steps;\n    this._waitSeconds = waitSeconds;\n    this._alarms = alarms;\n  }\n\n  /**\n   * Whether traffic moves in steps (canary or linear) rather than all at once.\n   *\n   * @internal\n   */\n  public get _gradual(): boolean {\n    return this._steps.length > 1;\n  }\n}\n\nfunction wholePercent(kind: string, name: string, value: number, min: number, max: number): number {\n  if (Token.isUnresolved(value) || !Number.isInteger(value) || value < min || value > max) {\n    throw new Error(`WebFunctionDeployment.${kind}: ${name} must be a whole number from ${Math.ceil(min)} to ${max}, got ${value}`);\n  }\n  return value;\n}\n\nfunction minutes(kind: string, name: string, value: Duration, maxMinutes: number): Duration {\n  const seconds = value.toSeconds();\n  if (Token.isUnresolved(seconds) || seconds < 60 || seconds > maxMinutes * 60) {\n    throw new Error(`WebFunctionDeployment.${kind}: ${name} must be from 1 to ${maxMinutes} minutes, got ${Token.isUnresolved(seconds) ? 'a token' : value.toHumanString()}`);\n  }\n  return Duration.seconds(seconds);\n}\n"]}
+function rollbackOn(kind, options) {
+    if (options === undefined)
+        return undefined;
+    const fail = (message) => {
+        throw new Error(`WebFunctionDeployment.${kind}: rollbackOn.${message}`);
+    };
+    if (options.serverErrorRate === undefined && options.clientErrorRate === undefined) {
+        fail('serverErrorRate or rollbackOn.clientErrorRate is required');
+    }
+    for (const [name, rate] of [['serverErrorRate', options.serverErrorRate], ['clientErrorRate', options.clientErrorRate]]) {
+        if (rate !== undefined && (aws_cdk_lib_1.Token.isUnresolved(rate) || !(rate >= 0 && rate < 100)))
+            fail(`${name} must be a percentage from 0 to below 100, got ${rate}`);
+    }
+    const minimumRequests = options.minimumRequests ?? 10;
+    if (aws_cdk_lib_1.Token.isUnresolved(minimumRequests) || !Number.isInteger(minimumRequests) || minimumRequests < 1) {
+        fail(`minimumRequests must be a whole number from 1, got ${minimumRequests}`);
+    }
+    const period = options.period ?? aws_cdk_lib_1.Duration.minutes(1);
+    const seconds = period.toSeconds();
+    if (aws_cdk_lib_1.Token.isUnresolved(seconds) || seconds < 60 || seconds % 60 !== 0) {
+        fail(`period must be whole minutes, at least 1, got ${aws_cdk_lib_1.Token.isUnresolved(seconds) ? 'a token' : period.toHumanString()}`);
+    }
+    const evaluationPeriods = options.evaluationPeriods ?? 2;
+    if (aws_cdk_lib_1.Token.isUnresolved(evaluationPeriods) || !Number.isInteger(evaluationPeriods) || evaluationPeriods < 1) {
+        fail(`evaluationPeriods must be a whole number from 1, got ${evaluationPeriods}`);
+    }
+    return { serverErrorRate: options.serverErrorRate, clientErrorRate: options.clientErrorRate, minimumRequests, period, evaluationPeriods };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-function-deployment.js","sourceRoot":"","sources":["../src/web-function-deployment.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, Token } from 'aws-cdk-lib';\nimport type * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport type { ResolvedRollbackOptions } from './private/rollback';\n\n/** Longest total wait of a deployment: the deployment step must finish within CloudFormation's 1-hour custom resource limit. */\nconst MAX_TOTAL_WAIT_MINUTES = 45;\n/** Most traffic steps: each one also waits for the endpoint to update in every region. */\nconst MAX_STEPS = 20;\n\n/**\n * Alarms an endpoint creates on its own metrics to stop a canary or linear deployment.\n *\n * The endpoint creates one alarm per threshold in every region it serves from (metrics are published\n * in the region that served the request, and an alarm can only watch metrics in its own region).\n * Lambda Web Function metrics have no revision dimension, so the alarms watch the whole endpoint: while\n * the new revision gets 10% of the traffic, its errors are about a tenth of the endpoint's.\n */\nexport interface WebFunctionRollbackOptions {\n  /**\n   * Roll back when more than this percent of the endpoint's requests get a 5XX response (0-100).\n   *\n   * 5XX includes the platform's 503s while an endpoint scales up for a sudden burst, not only your application's errors.\n   *\n   * @default - no server error alarm\n   */\n  readonly serverErrorRate?: number;\n\n  /**\n   * Roll back when more than this percent of the endpoint's requests get a 4XX response (0-100).\n   * Requests over `rateLimit` or `maxEnvironments` get 429, which counts here.\n   *\n   * @default - no client error alarm\n   */\n  readonly clientErrorRate?: number;\n\n  /**\n   * Periods with fewer requests than this don't count, so one failed request out of two doesn't roll back.\n   *\n   * @default 10\n   */\n  readonly minimumRequests?: number;\n\n  /**\n   * The period each rate is measured over (at least 1 minute, in whole minutes).\n   *\n   * @default Duration.minutes(1)\n   */\n  readonly period?: Duration;\n\n  /**\n   * How many consecutive periods must breach a threshold before the deployment rolls back.\n   *\n   * @default 2\n   */\n  readonly evaluationPeriods?: number;\n}\n\n/**\n * Options for a canary deployment.\n */\nexport interface WebFunctionCanaryDeploymentOptions {\n  /**\n   * The share of traffic, in whole percent (1-99), that the new revision gets first.\n   */\n  readonly percent: number;\n\n  /**\n   * How long the new revision serves `percent` before it gets all traffic (1-45 minutes).\n   * Make it longer than the time your alarms need to fire (period × evaluation periods).\n   */\n  readonly bake: Duration;\n\n  /**\n   * Alarms that stop the deployment: if one is in ALARM, the endpoint goes back to the previous\n   * revision and the deployment fails, so CloudFormation rolls the stack back.\n   *\n   * They're checked before traffic moves, during the bake, and once the new revision has all traffic.\n   * Use alarms in any region (by ARN), including composite alarms.\n   *\n   * @default - no alarms: traffic moves on a timer\n   */\n  readonly alarms?: cloudwatch.IAlarm[];\n\n  /**\n   * Alarms on the endpoint's own error rates, created by the endpoint in every region it serves from.\n   * They stop the deployment like `alarms` (both can be used together).\n   *\n   * @default - no endpoint alarms\n   */\n  readonly rollbackOn?: WebFunctionRollbackOptions;\n}\n\n/**\n * Options for a linear deployment.\n */\nexport interface WebFunctionLinearDeploymentOptions {\n  /**\n   * The share of traffic, in whole percent (5-50), that moves to the new revision at each step.\n   */\n  readonly percent: number;\n\n  /**\n   * How long each step serves before the next one (at least 1 minute, and at most 45 minutes in total).\n   */\n  readonly interval: Duration;\n\n  /**\n   * Alarms that stop the deployment: if one is in ALARM, the endpoint goes back to the previous\n   * revision and the deployment fails, so CloudFormation rolls the stack back.\n   *\n   * They're checked before traffic moves, during every step, and once the new revision has all traffic.\n   * Use alarms in any region (by ARN), including composite alarms.\n   *\n   * @default - no alarms: traffic moves on a timer\n   */\n  readonly alarms?: cloudwatch.IAlarm[];\n\n  /**\n   * Alarms on the endpoint's own error rates, created by the endpoint in every region it serves from.\n   * They stop the deployment like `alarms` (both can be used together).\n   *\n   * @default - no endpoint alarms\n   */\n  readonly rollbackOn?: WebFunctionRollbackOptions;\n}\n\n/**\n * How an endpoint moves its traffic to a new revision.\n */\nexport class WebFunctionDeployment {\n  /**\n   * All traffic moves to the new revision at once, as soon as it's ready (the default).\n   */\n  public static allAtOnce(): WebFunctionDeployment {\n    return new WebFunctionDeployment('allAtOnce', [100], 0, [], undefined);\n  }\n\n  /**\n   * The new revision first gets `percent` of the traffic for `bake`, then all of it.\n   */\n  public static canary(options: WebFunctionCanaryDeploymentOptions): WebFunctionDeployment {\n    const percent = wholePercent('canary', 'percent', options.percent, 1, 99);\n    const bake = minutes('canary', 'bake', options.bake, MAX_TOTAL_WAIT_MINUTES);\n    return new WebFunctionDeployment('canary', [percent, 100], bake.toSeconds(), options.alarms ?? [], rollbackOn('canary', options.rollbackOn));\n  }\n\n  /**\n   * The new revision gets `percent` more of the traffic every `interval` until it has all of it.\n   */\n  public static linear(options: WebFunctionLinearDeploymentOptions): WebFunctionDeployment {\n    const percent = wholePercent('linear', 'percent', options.percent, 100 / MAX_STEPS, 50);\n    const interval = minutes('linear', 'interval', options.interval, MAX_TOTAL_WAIT_MINUTES);\n    const steps: number[] = [];\n    for (let p = percent; p < 100; p += percent) steps.push(p);\n    steps.push(100);\n    const total = interval.toSeconds() * (steps.length - 1);\n    if (total > MAX_TOTAL_WAIT_MINUTES * 60) {\n      throw new Error(`WebFunctionDeployment.linear: ${steps.length - 1} intervals of ${interval.toHumanString()} take ${total / 60} minutes; at most ${MAX_TOTAL_WAIT_MINUTES} are allowed`);\n    }\n    return new WebFunctionDeployment('linear', steps, interval.toSeconds(), options.alarms ?? [], rollbackOn('linear', options.rollbackOn));\n  }\n\n  /**\n   * The new revision's share of traffic at each step, in percent; the last is 100.\n   *\n   * @internal\n   */\n  public readonly _steps: number[];\n\n  /**\n   * Seconds each step serves before the next.\n   *\n   * @internal\n   */\n  public readonly _waitSeconds: number;\n\n  /** @internal */\n  public readonly _alarms: cloudwatch.IAlarm[];\n\n  /** @internal */\n  public readonly _kind: string;\n\n  /**\n   * Thresholds for the alarms the endpoint creates, with defaults applied.\n   *\n   * @internal\n   */\n  public readonly _rollbackOn?: ResolvedRollbackOptions;\n\n  private constructor(\n    kind: string, steps: number[], waitSeconds: number, alarms: cloudwatch.IAlarm[], rollback: ResolvedRollbackOptions | undefined,\n  ) {\n    this._kind = kind;\n    this._steps = steps;\n    this._waitSeconds = waitSeconds;\n    this._alarms = alarms;\n    this._rollbackOn = rollback;\n  }\n\n  /**\n   * Whether traffic moves in steps (canary or linear) rather than all at once.\n   *\n   * @internal\n   */\n  public get _gradual(): boolean {\n    return this._steps.length > 1;\n  }\n}\n\nfunction wholePercent(kind: string, name: string, value: number, min: number, max: number): number {\n  if (Token.isUnresolved(value) || !Number.isInteger(value) || value < min || value > max) {\n    throw new Error(`WebFunctionDeployment.${kind}: ${name} must be a whole number from ${Math.ceil(min)} to ${max}, got ${value}`);\n  }\n  return value;\n}\n\nfunction minutes(kind: string, name: string, value: Duration, maxMinutes: number): Duration {\n  const seconds = value.toSeconds();\n  if (Token.isUnresolved(seconds) || seconds < 60 || seconds > maxMinutes * 60) {\n    throw new Error(`WebFunctionDeployment.${kind}: ${name} must be from 1 to ${maxMinutes} minutes, got ${Token.isUnresolved(seconds) ? 'a token' : value.toHumanString()}`);\n  }\n  return Duration.seconds(seconds);\n}\n\nfunction rollbackOn(kind: string, options: WebFunctionRollbackOptions | undefined): ResolvedRollbackOptions | undefined {\n  if (options === undefined) return undefined;\n  const fail = (message: string) => {\n    throw new Error(`WebFunctionDeployment.${kind}: rollbackOn.${message}`);\n  };\n  if (options.serverErrorRate === undefined && options.clientErrorRate === undefined) {\n    fail('serverErrorRate or rollbackOn.clientErrorRate is required');\n  }\n  for (const [name, rate] of [['serverErrorRate', options.serverErrorRate], ['clientErrorRate', options.clientErrorRate]] as const) {\n    if (rate !== undefined && (Token.isUnresolved(rate) || !(rate >= 0 && rate < 100))) fail(`${name} must be a percentage from 0 to below 100, got ${rate}`);\n  }\n  const minimumRequests = options.minimumRequests ?? 10;\n  if (Token.isUnresolved(minimumRequests) || !Number.isInteger(minimumRequests) || minimumRequests < 1) {\n    fail(`minimumRequests must be a whole number from 1, got ${minimumRequests}`);\n  }\n  const period = options.period ?? Duration.minutes(1);\n  const seconds = period.toSeconds();\n  if (Token.isUnresolved(seconds) || seconds < 60 || seconds % 60 !== 0) {\n    fail(`period must be whole minutes, at least 1, got ${Token.isUnresolved(seconds) ? 'a token' : period.toHumanString()}`);\n  }\n  const evaluationPeriods = options.evaluationPeriods ?? 2;\n  if (Token.isUnresolved(evaluationPeriods) || !Number.isInteger(evaluationPeriods) || evaluationPeriods < 1) {\n    fail(`evaluationPeriods must be a whole number from 1, got ${evaluationPeriods}`);\n  }\n  return { serverErrorRate: options.serverErrorRate, clientErrorRate: options.clientErrorRate, minimumRequests, period, evaluationPeriods };\n}\n"]}

package/lib/web-function-endpoint.d.ts

@@ -1,3 +1,4 @@
+import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import { Construct } from 'constructs';
 import { WebFunctionAuthType, WebFunctionEndpointType } from './enums';
@@ -151,6 +152,11 @@ export declare class WebFunctionEndpoint extends Construct {
     readonly url: string;
     /** Grants on this endpoint (e.g. `grants.invoke(principal)`). */
     readonly grants: WebFunctionGrants;
+    /**
+     * The alarms this endpoint created for its deployment's `rollbackOn`, one per threshold in every region it serves from
+     * (the home region's first). Empty without `rollbackOn`.
+     */
+    readonly rollbackAlarms: cloudwatch.IAlarm[];
     private readonly homeRegion;
     private readonly webFunction;
     private readonly resource;
@@ -181,10 +187,50 @@ export declare class WebFunctionEndpoint extends Construct {
      * @internal
      */
     _revisionIds(): string[];
+    /**
+     * A metric of this endpoint in `AWS/Lambda/Web` (dimensions `FunctionName` and `EndpointName`).
+     *
+     * Metrics are published in the region that served the request: pass `region` for one of the endpoint's
+     * other regions. An alarm can only use metrics from its own stack's region.
+     *
+     * @default - sum over 1 minute, in the home region
+     */
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /** Requests the endpoint served (`ExecutedRequests`). There's no separate count of successful (2XX) responses. */
+    metricRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Requests answered with a 4XX status (`HTTPResponseStatusClass4XX`), including 429s from `rateLimit` and `maxEnvironments`.
+     * The metric only exists once it's non-zero, so alarms should treat missing data as not breaching.
+     */
+    metricClientErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Requests answered with a 5XX status (`HTTPResponseStatusClass5XX`). Includes the platform's 503s while the endpoint
+     * scales up for a sudden burst, not only your application's errors. The metric only exists once it's non-zero.
+     */
+    metricServerErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /** The percentage of requests answered with a 4XX status (math expression; periods with no 4XX count as 0). */
+    metricClientErrorRate(props?: cloudwatch.MetricOptions): cloudwatch.MathExpression;
+    /** The percentage of requests answered with a 5XX status (math expression; periods with no 5XX count as 0). */
+    metricServerErrorRate(props?: cloudwatch.MetricOptions): cloudwatch.MathExpression;
+    /**
+     * Execution environments serving the endpoint (`EndpointActiveEnvironments`), to compare with `maxEnvironments`.
+     *
+     * @default - maximum over 1 minute, in the home region
+     */
+    metricActiveEnvironments(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /** Requests rejected with 429 because the endpoint reached its `rateLimit` (`EndpointRequestThrottles`). */
+    metricRequestThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /** Requests rejected with 429 because the endpoint reached `maxEnvironments` (`EndpointActiveEnvironmentThrottles`). */
+    metricEnvironmentThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
      * Allows `grantee` to call this endpoint. Shortcut for `grants.invoke(grantee)`.
      * [disable-awslint:no-grants]
      */
     grantInvoke(grantee: iam.IGrantable): iam.Grant;
+    private metricIds;
+    private rate;
+    private usageMetric;
+    /** One alarm per threshold in every serving region: a CloudFormation alarm at home, a custom resource elsewhere. Returns their ARNs. */
+    private createRollbackAlarms;
 }
 export {};