@cdklabs/multi-az-observability 0.0.1-alpha.6 → 0.0.1-alpha.60

package/README.md

@@ -1,175 +1,199 @@
+![Build Workflow](https://github.com/cdklabs/cdk-multi-az-observability/actions/workflows/build.yml/badge.svg) ![Release Workflow](https://github.com/cdklabs/cdk-multi-az-observability/actions/workflows/release.yml/badge.svg) ![GitHub Release](https://img.shields.io/github/v/release/cdklabs/cdk-multi-az-observability?include_prereleases&sort=semver&logo=github&label=version)
+
 # multi-az-observability
 This is a CDK construct for multi-AZ observability to help detect single-AZ impairments. This is currently an `alpha` version, but is being used in the AWS [Advanced Multi-AZ Resilience Patterns](https://catalog.workshops.aws/multi-az-gray-failures/en-US) workshop.
 
-There is a lot of available information to think through and combine to provide signals about single-AZ impact. To simplify the setup and use reasonable defaults, this construct (available in TypeScript, Go, Python, and .NET [Java coming soon]) sets up the necessary observability. To use the CDK construct, you first define your service like this:
+There is a lot of available information to think through and combine to provide signals about single-AZ impact. To simplify the setup and use reasonable defaults, this construct (available in [TypeScript](https://www.npmjs.com/package/@cdklabs/multi-az-observability), [Go](https://github.com/cdklabs/cdk-multi-az-observability-go), [Python](https://pypi.org/project/cdklabs.multi-az-observability/), [.NET](https://www.nuget.org/packages/Cdklabs.MultiAZObservability), and [Java](https://central.sonatype.com/artifact/io.github.cdklabs/cdk-multi-az-observability)) sets up the necessary observability. To use the CDK construct, you first define your service like this:
 
-```csharp
-var wildRydesService = new Service(new ServiceProps(){
-    ServiceName = "WildRydes",
-    BaseUrl = "http://www.example.com",
-    FaultCountThreshold = 25,
-    AvailabilityZoneNames = vpc.AvailabilityZones,
-    Period = Duration.Seconds(60),
-    LoadBalancer = loadBalancer,
-    DefaultAvailabilityMetricDetails = new ServiceMetricDetails(new ServiceMetricDetailsProps() {
-        AlarmStatistic = "Sum",
-        DatapointsToAlarm = 3,
-        EvaluationPeriods = 5,
-        FaultAlarmThreshold = 1,
-        FaultMetricNames = new string[] { "Fault", "Error" },
-        GraphedFaultStatistics = new string[] { "Sum" },
-        GraphedSuccessStatistics = new string[] { "Sum" },
-        MetricNamespace = metricsNamespace,
-        Period = Duration.Seconds(60),
-        SuccessAlarmThreshold = 99,
-        SuccessMetricNames = new string[] {"Success"},
-        Unit = Unit.COUNT,
+```typescript
+let service: IService = new Service({
+    serviceName: 'test',
+    availabilityZoneNames: vpc.availabilityZones,
+    baseUrl: 'http://www.example.com',
+    faultCountThreshold: 25,
+    period: Duration.seconds(60),
+    loadBalancer: loadBalancer,
+    targetGroups: [ targetGroup1, targetGroup2 ],
+    defaultAvailabilityMetricDetails: new ServiceAvailabilityMetricDetails({
+      metricNamespace: 'front-end/metrics',
+      successMetricNames: ['Success'],
+      faultMetricNames: ['Fault', 'Error'],
+      alarmStatistic: 'Sum',
+      unit: Unit.COUNT,
+      period: Duration.seconds(60),
+      evaluationPeriods: 5,
+      datapointsToAlarm: 3,
+      successAlarmThreshold: 99.9,
+      faultAlarmThreshold: 0.1,
+      graphedFaultStatistics: ['Sum'],
+      graphedSuccessStatistics: ['Sum'],
     }),
-    DefaultLatencyMetricDetails = new ServiceMetricDetails(new ServiceMetricDetailsProps(){
-        AlarmStatistic = "p99",
-        DatapointsToAlarm = 3,
-        EvaluationPeriods = 5,
-        FaultAlarmThreshold = 1,
-        FaultMetricNames = new string[] { "FaultLatency" },
-        GraphedFaultStatistics = new string[] { "p50" },
-        GraphedSuccessStatistics = new string[] { "p50", "p99", "tm50", "tm99" },
-        MetricNamespace = metricsNamespace,
-        Period = Duration.Seconds(60),
-        SuccessAlarmThreshold = 100,
-        SuccessMetricNames = new string[] {"SuccessLatency"},
-        Unit = Unit.MILLISECONDS,
+    defaultLatencyMetricDetails: new ServiceLatencyMetricDetails({
+      metricNamespace: 'front-end/metrics',
+      successMetricNames: ['SuccessLatency'],
+      faultMetricNames: ['FaultLatency'],
+      alarmStatistic: 'p99',
+      unit: Unit.MILLISECONDS,
+      period: Duration.seconds(60),
+      evaluationPeriods: 5,
+      datapointsToAlarm: 3,
+      successAlarmThreshold: Duration.millis(150),
+      graphedFaultStatistics: ['p99'],
+      graphedSuccessStatistics: ['p50', 'p99', 'tm99'],
     }),
-    DefaultContributorInsightRuleDetails =  new ContributorInsightRuleDetails(new ContributorInsightRuleDetailsProps() {
-        AvailabilityZoneIdJsonPath = azIdJsonPath,
-        FaultMetricJsonPath = faultMetricJsonPath,
-        InstanceIdJsonPath = instanceIdJsonPath,
-        LogGroups = serverLogGroups,
-        OperationNameJsonPath = operationNameJsonPath,
-        SuccessLatencyMetricJsonPath = successLatencyMetricJsonPath
+    defaultContributorInsightRuleDetails: new ContributorInsightRuleDetails({
+      successLatencyMetricJsonPath: '$.SuccessLatency',
+      faultMetricJsonPath: '$.Faults',
+      operationNameJsonPath: '$.Operation',
+      instanceIdJsonPath: '$.InstanceId',
+      availabilityZoneIdJsonPath: '$.AZ-ID',
+      logGroups: [logGroup],
     }),
-    CanaryTestProps = new AddCanaryTestProps() {
-        RequestCount = 10,
-        LoadBalancer = loadBalancer,
-        Schedule = "rate(1 minute)",
-        NetworkConfiguration = new NetworkConfigurationProps() {
-            Vpc = vpc,
-            SubnetSelection = new SubnetSelection() { SubnetType = SubnetType.PRIVATE_ISOLATED }
-        }
+    canaryTestProps: {
+      requestCount: 10,
+      schedule: 'rate(1 minute)',
+      loadBalancer: loadBalancer,
+      networkConfiguration: {
+        vpc: vpc,
+        subnetSelection: { subnetType: SubnetType.PRIVATE_ISOLATED },
+      },
+    },
+    minimumUnhealthyTargets: {
+        percentage: 0.1
     }
-});
-wildRydesService.AddOperation(new Operation(new OperationProps() {
-    OperationName = "Signin",
-    Path = "/signin",
-    Service = wildRydesService,
-    Critical = true,
-    HttpMethods = new string[] { "GET" },
-    ServerSideAvailabilityMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
-        OperationName = "Signin",
-        MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Signin"}}, "AZ-ID", "Region")
-    }, wildRydesService.DefaultAvailabilityMetricDetails),
-    ServerSideLatencyMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
-        OperationName = "Signin",
-        SuccessAlarmThreshold = 150,
-        MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Signin"}}, "AZ-ID", "Region")
-    }, wildRydesService.DefaultLatencyMetricDetails),
-    CanaryTestLatencyMetricsOverride = new CanaryTestMetricsOverride(new CanaryTestMetricsOverrideProps() {
-        SuccessAlarmThreshold = 250
-    })
-}));
-wildRydesService.AddOperation(new Operation(new OperationProps() {
-    OperationName = "Pay",
-    Path = "/pay",
-    Service = wildRydesService,
-    HttpMethods = new string[] { "GET" },
-    Critical = true,
-    ServerSideAvailabilityMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
-        OperationName = "Pay",
-        MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Pay"}}, "AZ-ID", "Region")
-    }, wildRydesService.DefaultAvailabilityMetricDetails),
-    ServerSideLatencyMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
-        OperationName = "Pay",
-        SuccessAlarmThreshold = 200,
-        MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Pay"}}, "AZ-ID", "Region")
-    }, wildRydesService.DefaultLatencyMetricDetails),
-    CanaryTestLatencyMetricsOverride = new CanaryTestMetricsOverride(new CanaryTestMetricsOverrideProps() {
-        SuccessAlarmThreshold = 300
-    })
-}));
-wildRydesService.AddOperation(new Operation(new OperationProps() {
-    OperationName = "Ride",
-    Path = "/ride",
-    Service = wildRydesService,
-    HttpMethods = new string[] { "GET" },
-    Critical = true,
-    ServerSideAvailabilityMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
-        OperationName = "Ride",
-        MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Ride"}}, "AZ-ID", "Region")
-    }, wildRydesService.DefaultAvailabilityMetricDetails),
-    ServerSideLatencyMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
-        OperationName = "Ride",
-        SuccessAlarmThreshold = 350,
-        MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Ride"}}, "AZ-ID", "Region")
-    }, wildRydesService.DefaultLatencyMetricDetails),
-    CanaryTestLatencyMetricsOverride = new CanaryTestMetricsOverride(new CanaryTestMetricsOverrideProps() {
-        SuccessAlarmThreshold = 550
-    })
-}));
-wildRydesService.AddOperation(new Operation(new OperationProps() {
-    OperationName = "Home",
-    Path = "/home",
-    Service = wildRydesService,
-    HttpMethods = new string[] { "GET" },
-    Critical = true,
-    ServerSideAvailabilityMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
-        OperationName = "Home",
-        MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Ride"}}, "AZ-ID", "Region")
-    }, wildRydesService.DefaultAvailabilityMetricDetails),
-    ServerSideLatencyMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
-        OperationName = "Home",
-        SuccessAlarmThreshold = 100,
-        MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Ride"}}, "AZ-ID", "Region")
-    }, wildRydesService.DefaultLatencyMetricDetails),
-    CanaryTestLatencyMetricsOverride = new CanaryTestMetricsOverride(new CanaryTestMetricsOverrideProps() {
-        SuccessAlarmThreshold = 200
-    })
-}));
+  });
+
+let rideOperation: Operation = {
+    operationName: 'ride',
+    service: service,
+    path: '/ride',
+    critical: true,
+    httpMethods: ['GET'],
+    serverSideContributorInsightRuleDetails: new ContributorInsightRuleDetails({
+      logGroups: [logGroup],
+      successLatencyMetricJsonPath: '$.SuccessLatency',
+      faultMetricJsonPath: '$.Faults',
+      operationNameJsonPath: '$.Operation',
+      instanceIdJsonPath: '$.InstanceId',
+      availabilityZoneIdJsonPath: '$.AZ-ID',
+    }),
+    serverSideAvailabilityMetricDetails: new OperationAvailabilityMetricDetails(
+      {
+        operationName: 'ride',
+        metricDimensions: new MetricDimensions(
+          { Operation: 'ride' },
+          'AZ-ID',
+          'Region',
+        ),
+      },
+      service.defaultAvailabilityMetricDetails,
+    ),
+    serverSideLatencyMetricDetails: new OperationLatencyMetricDetails(
+      {
+        operationName: 'ride',
+        metricDimensions: new MetricDimensions(
+          { Operation: 'ride' },
+          'AZ-ID',
+          'Region',
+        ),
+      },
+      service.defaultLatencyMetricDetails,
+    ),
+};
+
+let payOperation: Operation = {
+    operationName: 'pay',
+    service: service,
+    path: '/pay',
+    critical: true,
+    httpMethods: ['GET'],
+    serverSideContributorInsightRuleDetails: new ContributorInsightRuleDetails({
+      logGroups: [logGroup],
+      successLatencyMetricJsonPath: '$.SuccessLatency',
+      faultMetricJsonPath: '$.Faults',
+      operationNameJsonPath: '$.Operation',
+      instanceIdJsonPath: '$.InstanceId',
+      availabilityZoneIdJsonPath: '$.AZ-ID',
+    }),
+    serverSideAvailabilityMetricDetails: new OperationAvailabilityMetricDetails(
+      {
+        operationName: 'pay',
+        metricDimensions: new MetricDimensions(
+          { Operation: 'ride' },
+          'AZ-ID',
+          'Region',
+        ),
+      },
+      service.defaultAvailabilityMetricDetails,
+    ),
+    serverSideLatencyMetricDetails: new OperationLatencyMetricDetails(
+      {
+        operationName: 'pay',
+        metricDimensions: new MetricDimensions(
+          { Operation: 'ride' },
+          'AZ-ID',
+          'Region',
+        ),
+      },
+      service.defaultLatencyMetricDetails,
+    ),
+};
+
+service.addOperation(rideOperation);
+service.addOperation(payOperation);
 ```
 
 Then you provide that service definition to the CDK construct.
 
-```csharp
-InstrumentedServiceMultiAZObservability multiAvailabilityZoneObservability = new InstrumentedServiceMultiAZObservability(this, "MultiAZObservability", new InstrumentedServiceMultiAZObservabilityProps() {
-    Service = wildRydesService,
-    CreateDashboards = true,
-    Interval = Duration.Minutes(60), // The interval for the dashboard
-    OutlierDetectionAlgorithm = OutlierDetectionAlgorithm.STATIC
+```typescript fixture=service
+new InstrumentedServiceMultiAZObservability(stack, 'MAZObservability', {
+    createDashboards: true,
+    service: service,
+    interval: Duration.minutes(60)
 });
 ```
 
-You define some characteristics of the service, default values for metrics and alarms, and then add operations as well as any overrides for default values that you need. The construct can also automatically create synthetic canaries that test each operation with a very simple HTTP check, or you can configure your own synthetics and just tell the construct about the metric details and optionally log files. This creates metrics, alarms, and dashboards that can be used to detect single-AZ impact.
+You define some characteristics of the service, default values for metrics and alarms, and then add operations as well as any overrides for default values that you need. The construct can also automatically create synthetic canaries that test each operation with a very simple HTTP check, or you can configure your own synthetics and just tell the construct about the metric details and optionally log files. This creates metrics, alarms, and dashboards that can be used to detect single-AZ impact. You can access these alarms from the `multiAvailabilityZoneObservability` object and use them in your CDK project to start automation, send SNS notifications, or incorporate in your own dashboards.
 
-If you don't have service specific logs and custom metrics with per-AZ dimensions, you can still use the construct to evaluate ALB and NAT Gateway metrics to find single AZ faults.
+If you don't have service specific logs and custom metrics with per-AZ dimensions, you can still use the construct to evaluate ALB and/or NAT Gateway metrics to find single AZ impairments.
 
-```csharp
-BasicServiceMultiAZObservability multiAvailabilityZoneObservability = new BasicServiceMultiAZObservability(this, "MultiAZObservability", new BasicServiceMultiAZObservabilityProps() {
-    ApplicationLoadBalancers = new IApplicationLoadBalancer[] { loadBalancer },
-    NatGateways = new Dictionary<string, CfnNatGateway>() {
-        { "us-east-1a", natGateway1},
-        { "us-east-1b", natGateway2},
-        { "us-east-1c", natGateway3},
+```typescript
+new BasicServiceMultiAZObservability(stack, 'MAZObservability', {
+    applicationLoadBalancerProps: {
+      albTargetGroupMap: [
+        {
+          applicationLoadBalancer: new ApplicationLoadBalancer(stack, 'alb', {
+            vpc: vpc,
+            crossZoneEnabled: true,
+          }),
+          targetGroups: [
+            targetGroup1,
+            targetGroup2
+          ]
+        }
+      ],
+      faultCountPercentThreshold: 1,
+      latencyStatistic: Stats.percentile(99),
+      latencyThreshold: Duration.millis(200),
+      latencyOutlierAlgorithm: ApplicationLoadBalancerLatencyOutlierAlgorithm.STATIC,
+      latencyOutlierThreshold: 45
+    },
+    natGatewayProps: {
+       natGateways: {
+            "us-east-1a": [ natGateway1 ],
+            "us-east-1b": [ natGateway2 ],
+            "us-east-1c": [ natGateway3 ]
+        },
+        packetLossPercentThreshold: 0.01
     },
-    CreateDashboard = true,
-    OutlierDetectionAlgorithm = OutlierDetectionAlgorithm.STATIC,
-    FaultCountPercentageThreshold = 1.0, // The fault rate to alarm on for errors seen from the ALBs in the same AZ
-    PacketLossImpactPercentageThreshold = 0.01, // The percentage of packet loss to alarm on for the NAT Gateways in the same AZ
-    ServiceName = "WildRydes",
-    Period = Duration.Seconds(60), // The period for metric evaluation
-    Interval = Duration.Minutes(60) // The interval for the dashboards
-    EvaluationPeriods = 5,
-    DatapointsToAlarm = 3
+    serviceName: 'test',
+    period: Duration.seconds(60),
+    createDashboard: true,
+    evaluationPeriods: 5,
+    datapointsToAlarm: 3,
 });
 ```
 
 If you provide a load balancer, the construct assumes it is deployed in each AZ of the VPC the load balancer is associated with and will look for HTTP metrics using those AZs as dimensions.
 
-Both options support running workloads on EC2, ECS, Lambda, and EKS.
+Both options support running workloads on EC2, ECS, Lambda, and EKS.

package/lib/alarmsandrules/AvailabilityAndLatencyAlarmsAndRules.d.ts

@@ -9,6 +9,10 @@ import { IContributorInsightRuleDetails } from '../services/IContributorInsightR
 import { IOperation } from '../services/IOperation';
 import { IOperationMetricDetails } from '../services/IOperationMetricDetails';
 import { OutlierDetectionAlgorithm } from '../utilities/OutlierDetectionAlgorithm';
+import { IOperationAvailabilityMetricDetails } from '../services/IOperationAvailabilityMetricDetails';
+import { IOperationLatencyMetricDetails } from '../services/IOperationLatencyMetricDetails';
+import { LatencyOutlierMetricAggregation } from '../outlier-detection/LatencyOutlierMetricAggregation';
+import { MinimumUnhealthyTargets } from '../utilities/MinimumUnhealthyTargets';
 /**
  * Class used to create availability and latency alarms and Contributor Insight rules
  */
@@ -22,7 +26,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param counter
      * @returns
      */
-    static createZonalAvailabilityAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, counter: number, nameSuffix?: string): IAlarm;
+    static createZonalAvailabilityAlarm(scope: Construct, metricDetails: IOperationAvailabilityMetricDetails, availabilityZone: string, availabilityZoneId: string, counter: number, nameSuffix?: string): IAlarm;
     /**
      * Creates a zonal latency alarm
      * @param scope
@@ -32,7 +36,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param counter
      * @returns
      */
-    static createZonalLatencyAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, counter: number, nameSuffix?: string): IAlarm;
+    static createZonalLatencyAlarm(scope: Construct, metricDetails: IOperationLatencyMetricDetails, availabilityZone: string, availabilityZoneId: string, counter: number, nameSuffix?: string): IAlarm;
     /**
      * Creates a composite alarm when either latency or availability is breached in the Availabiltiy Zone
      * @param scope
@@ -55,7 +59,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param outlierThreshold
      * @returns
      */
-    static createZonalFaultRateStaticOutlierAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, counter: number, outlierThreshold: number, nameSuffix?: string): IAlarm;
+    static createZonalFaultRateStaticOutlierAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZone: string, availabilityZoneId: string, counter: number, outlierThreshold: number, nameSuffix?: string): IAlarm;
     /**
    * An alarm that compares error rate in this AZ to the overall region error based only on metric data.
    * This is different for canaries because the metrics they test at the regional level are different
@@ -69,15 +73,15 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
    * @param outlierThreshold
    * @returns
    */
-    static createZonalFaultRateStaticOutlierAlarmForCanaries(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, availabilityZones: string[], counter: number, outlierThreshold: number, nameSuffix?: string): IAlarm;
+    static createZonalFaultRateStaticOutlierAlarmForCanaries(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZone: string, availabilityZoneId: string, availabilityZoneIds: string[], counter: number, outlierThreshold: number, nameSuffix?: string): IAlarm;
     static createZonalFaultRateOutlierAlarm(scope: IConstruct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, allAvailabilityZoneIds: string[], outlierThreshold: number, outlierDetectionFunction: IFunction, outlierDetectionAlgorithm: OutlierDetectionAlgorithm, counter: number, nameSuffix?: string): IAlarm;
     static createZonalFaultRateOutlierAlarmForAlb(scope: IConstruct, loadBalancers: IApplicationLoadBalancer[], availabilityZoneId: string, outlierThreshold: number, outlierDetectionFunction: IFunction, outlierDetectionAlgorithm: OutlierDetectionAlgorithm, azMapper: IAvailabilityZoneMapper, counter: number, evaluationPeriods: number, datapointsToAlarm: number, period: Duration, nameSuffix?: string): IAlarm;
     static createZonalFaultRateOutlierAlarmForNatGW(scope: IConstruct, natGateways: {
         [key: string]: CfnNatGateway[];
     }, availabilityZoneId: string, outlierThreshold: number, outlierDetectionFunction: IFunction, outlierDetectionAlgorithm: OutlierDetectionAlgorithm, azMapper: IAvailabilityZoneMapper, counter: number, evaluationPeriods: number, datapointsToAlarm: number, period: Duration, nameSuffix?: string): IAlarm;
-    static createZonalHighLatencyOutlierAlarm(scope: IConstruct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, allAvailabilityZoneIds: string[], outlierThreshold: number, outlierDetectionFunction: IFunction, outlierDetectionAlgorithm: OutlierDetectionAlgorithm, counter: number, nameSuffix?: string): IAlarm;
-    static createZonalHighLatencyStaticOutlierAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, counter: number, outlierThreshold: number, nameSuffix?: string): IAlarm;
-    static createZonalHighLatencyStaticOutlierAlarmForCanaries(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, availabilityZones: string[], counter: number, outlierThreshold: number, nameSuffix?: string): IAlarm;
+    static createZonalHighLatencyOutlierAlarm(scope: IConstruct, metricDetails: IOperationLatencyMetricDetails, availabilityZoneId: string, allAvailabilityZoneIds: string[], outlierThreshold: number, outlierDetectionFunction: IFunction, outlierMetric: LatencyOutlierMetricAggregation, outlierDetectionAlgorithm: OutlierDetectionAlgorithm, counter: number, nameSuffix?: string): IAlarm;
+    static createZonalHighLatencyStaticOutlierAlarm(scope: Construct, metricDetails: IOperationLatencyMetricDetails, availabilityZone: string, availabilityZoneId: string, counter: number, outlierThreshold: number, nameSuffix?: string): IAlarm;
+    static createZonalHighLatencyStaticOutlierAlarmForCanaries(scope: Construct, metricDetails: IOperationLatencyMetricDetails, availabilityZone: string, availabilityZoneId: string, availabilityZones: string[], counter: number, outlierThreshold: number, nameSuffix?: string): IAlarm;
     /**
      * An insight rule that calculates how many instances are responding to requests in
      * the specified AZ. Only useful for server-side metrics since the canary doesn't record instance id metrics.
@@ -120,7 +124,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param counter
      * @returns
      */
-    static createServerSideInstanceHighLatencyContributorsInThisAZRule(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, ruleDetails: IContributorInsightRuleDetails, counter: number, nameSuffix?: string): CfnInsightRule;
+    static createServerSideInstanceHighLatencyContributorsInThisAZRule(scope: Construct, metricDetails: IOperationLatencyMetricDetails, availabilityZoneId: string, ruleDetails: IContributorInsightRuleDetails, counter: number, nameSuffix?: string): CfnInsightRule;
     /**
      * An alarm that indicates some percentage of the instances in this AZ are producing errors. Only
      * useful for server-side metrics since the canary doesn't record instance id metrics.
@@ -134,7 +138,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param instancesHandlingRequestsInThisAZ
      * @returns
      */
-    static createServerSideZonalMoreThanOneInstanceProducingFaultsAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, counter: number, outlierThreshold: number, instanceFaultRateContributorsInThisAZ: CfnInsightRule, instancesHandlingRequestsInThisAZ: CfnInsightRule, nameSuffix?: string): IAlarm;
+    static createServerSideZonalMoreThanOneInstanceProducingFaultsAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, counter: number, instanceFaultRateContributorsInThisAZ: CfnInsightRule, instancesHandlingRequestsInThisAZ: CfnInsightRule, minimumUnhealthyTargets?: MinimumUnhealthyTargets, nameSuffix?: string): IAlarm;
     /**
      * An alarm indicating more than some percentage of instances in this AZ
      * are contributing to high latency. Only useful for server-side metrics since
@@ -149,7 +153,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param instancesHandlingRequestsInThisAZ
      * @returns
      */
-    static createServerSideZonalMoreThanOneInstanceProducingHighLatencyAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, counter: number, outlierThreshold: number, instanceHighLatencyContributorsInThisAZ: CfnInsightRule, instancesHandlingRequestsInThisAZ: CfnInsightRule, nameSuffix?: string): IAlarm;
+    static createServerSideZonalMoreThanOneInstanceProducingHighLatencyAlarm(scope: Construct, metricDetails: IOperationMetricDetails, availabilityZoneId: string, counter: number, instanceHighLatencyContributorsInThisAZ: CfnInsightRule, instancesHandlingRequestsInThisAZ: CfnInsightRule, minimumUnhealthyTargets?: MinimumUnhealthyTargets, nameSuffix?: string): IAlarm;
     /**
      * An alarm that indicates this AZ as an outlier
      * for availability or latency. This does not ensure that the errors
@@ -204,7 +208,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param counter
      * @returns
      */
-    static createRegionalAvailabilityAlarm(scope: Construct, metricDetails: IOperationMetricDetails, nameSuffix: string): IAlarm;
+    static createRegionalAvailabilityAlarm(scope: Construct, metricDetails: IOperationAvailabilityMetricDetails, nameSuffix: string): IAlarm;
     /**
      * Creates a regional latency alarm for the operation
      * @param scope
@@ -213,7 +217,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param counter
      * @returns
      */
-    static createRegionalLatencyAlarm(scope: Construct, metricDetails: IOperationMetricDetails, nameSuffix: string): IAlarm;
+    static createRegionalLatencyAlarm(scope: Construct, metricDetails: IOperationLatencyMetricDetails, nameSuffix: string): IAlarm;
     /**
      * A composite alarm combining latency and availability alarms for this operation in the region
      * as measured from either the server side or canary
@@ -224,7 +228,7 @@ export declare class AvailabilityAndLatencyAlarmsAndRules {
      * @param regionalLatencyAlarm
      * @returns
      */
-    static createRegionalCustomerExperienceAlarm(scope: Construct, operationName: string, nameSuffix: string, regionalAvailabilityAlarm: IAlarm, regionalLatencyAlarm: IAlarm): IAlarm;
-    static createRegionalInstanceContributorsToHighLatency(scope: Construct, metricDetails: IOperationMetricDetails, ruleDetails: IContributorInsightRuleDetails): CfnInsightRule;
+    static createRegionalAvailabilityOrLatencyImpactAlarm(scope: Construct, operationName: string, nameSuffix: string, regionalAvailabilityAlarm: IAlarm, regionalLatencyAlarm: IAlarm): IAlarm;
+    static createRegionalInstanceContributorsToHighLatency(scope: Construct, metricDetails: IOperationLatencyMetricDetails, ruleDetails: IContributorInsightRuleDetails): CfnInsightRule;
     static createRegionalInstanceContributorsToFaults(scope: Construct, metricDetails: IOperationMetricDetails, ruleDetails: IContributorInsightRuleDetails): CfnInsightRule;
 }