@cdklabs/multi-az-observability 0.0.0-alpha.0

package/lib/services/Operation.d.ts

@@ -0,0 +1,78 @@
+import { ICanaryMetrics } from './ICanaryMetrics';
+import { ICanaryTestMetricsOverride } from './ICanaryTestMetricsOverride';
+import { IContributorInsightRuleDetails } from './IContributorInsightRuleDetails';
+import { IOperation } from './IOperation';
+import { IOperationMetricDetails } from './IOperationMetricDetails';
+import { IService } from './IService';
+import { OperationProps } from './props/OperationProps';
+import { AddCanaryTestProps } from '../canaries/props/AddCanaryTestProps';
+/**
+ * A single operation that is part of a service
+ */
+export declare class Operation implements IOperation {
+    /**
+     * The service the operation is associated with
+     */
+    readonly service: IService;
+    /**
+     * The name of the operation
+     */
+    readonly operationName: string;
+    /**
+     *  The HTTP path for the operation for canaries
+     *  to run against, something like "/products/list"
+     */
+    readonly path: string;
+    /**
+     * The server side availability metric details
+     */
+    readonly serverSideAvailabilityMetricDetails: IOperationMetricDetails;
+    /**
+     * The server side latency metric details
+     */
+    readonly serverSideLatencyMetricDetails: IOperationMetricDetails;
+    /**
+     * Optional metric details if the service has a canary
+     */
+    readonly canaryMetricDetails?: ICanaryMetrics;
+    /**
+     * The override values for automatically created canary tests so you can
+     * use values other than the service defaults to define the thresholds for
+     * availability.
+     */
+    readonly canaryTestAvailabilityMetricsOverride?: ICanaryTestMetricsOverride;
+    /**
+     * The override values for automatically created canary tests so you can
+     * use values other than the service defaults to define the thresholds for
+     * latency.
+     */
+    readonly canaryTestLatencyMetricsOverride?: ICanaryTestMetricsOverride;
+    /**
+     * The server side details for contributor insights rules
+     */
+    readonly serverSideContributorInsightRuleDetails?: IContributorInsightRuleDetails;
+    /**
+     * Indicates this is a critical operation for the service
+     * and will be included in service level metrics and
+     * dashboards
+     */
+    readonly critical: boolean;
+    /**
+     * The http methods supported by the operation
+     */
+    readonly httpMethods: string[];
+    /**
+     * If they have been added, the properties for
+     * creating new canary tests on this operation
+     */
+    readonly canaryTestProps?: AddCanaryTestProps;
+    /**
+     * Set to true if you have defined CanaryTestProps for your
+     * service, which applies to all operations, but you want to
+     * opt out of creating the canary test for this operation.
+     *
+     * @default - The operation is not opted out
+     */
+    readonly optOutOfServiceCreatedCanary?: boolean;
+    constructor(props: OperationProps);
+}

package/lib/services/Operation.js

@@ -0,0 +1,34 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * A single operation that is part of a service
+ */
+class Operation {
+    constructor(props) {
+        this.canaryMetricDetails = props.canaryMetricDetails;
+        this.httpMethods = props.httpMethods;
+        this.critical = props.critical;
+        this.operationName = props.operationName;
+        this.path = props.path;
+        this.serverSideAvailabilityMetricDetails =
+            props.serverSideAvailabilityMetricDetails;
+        this.serverSideLatencyMetricDetails = props.serverSideLatencyMetricDetails;
+        this.serverSideContributorInsightRuleDetails =
+            props.serverSideContributorInsightRuleDetails;
+        this.service = props.service;
+        this.canaryTestProps = props.canaryTestProps;
+        this.optOutOfServiceCreatedCanary = props.optOutOfServiceCreatedCanary;
+        this.canaryTestAvailabilityMetricsOverride =
+            props.canaryTestAvailabilityMetricsOverride;
+        this.canaryTestLatencyMetricsOverride =
+            props.canaryTestLatencyMetricsOverride;
+        this.optOutOfServiceCreatedCanary = props.optOutOfServiceCreatedCanary;
+    }
+}
+exports.Operation = Operation;
+_a = JSII_RTTI_SYMBOL_1;
+Operation[_a] = { fqn: "@cdklabs/multi-az-observability.Operation", version: "0.0.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlcnZpY2VzL09wZXJhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQVdBOztHQUVHO0FBQ0gsTUFBYSxTQUFTO0lBOEVwQixZQUFZLEtBQXFCO1FBQy9CLElBQUksQ0FBQyxtQkFBbUIsR0FBRyxLQUFLLENBQUMsbUJBQW1CLENBQUM7UUFDckQsSUFBSSxDQUFDLFdBQVcsR0FBRyxLQUFLLENBQUMsV0FBVyxDQUFDO1FBQ3JDLElBQUksQ0FBQyxRQUFRLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQztRQUMvQixJQUFJLENBQUMsYUFBYSxHQUFHLEtBQUssQ0FBQyxhQUFhLENBQUM7UUFDekMsSUFBSSxDQUFDLElBQUksR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxtQ0FBbUM7WUFDdEMsS0FBSyxDQUFDLG1DQUFtQyxDQUFDO1FBQzVDLElBQUksQ0FBQyw4QkFBOEIsR0FBRyxLQUFLLENBQUMsOEJBQThCLENBQUM7UUFDM0UsSUFBSSxDQUFDLHVDQUF1QztZQUMxQyxLQUFLLENBQUMsdUNBQXVDLENBQUM7UUFDaEQsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDO1FBQzdCLElBQUksQ0FBQyxlQUFlLEdBQUcsS0FBSyxDQUFDLGVBQWUsQ0FBQztRQUM3QyxJQUFJLENBQUMsNEJBQTRCLEdBQUcsS0FBSyxDQUFDLDRCQUE0QixDQUFDO1FBQ3ZFLElBQUksQ0FBQyxxQ0FBcUM7WUFDeEMsS0FBSyxDQUFDLHFDQUFxQyxDQUFDO1FBQzlDLElBQUksQ0FBQyxnQ0FBZ0M7WUFDbkMsS0FBSyxDQUFDLGdDQUFnQyxDQUFDO1FBQ3pDLElBQUksQ0FBQyw0QkFBNEIsR0FBRyxLQUFLLENBQUMsNEJBQTRCLENBQUM7SUFDekUsQ0FBQzs7QUFqR0gsOEJBa0dDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IEFtYXpvbi5jb20sIEluYy4gb3IgaXRzIGFmZmlsaWF0ZXMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuaW1wb3J0IHsgSUNhbmFyeU1ldHJpY3MgfSBmcm9tICcuL0lDYW5hcnlNZXRyaWNzJztcbmltcG9ydCB7IElDYW5hcnlUZXN0TWV0cmljc092ZXJyaWRlIH0gZnJvbSAnLi9JQ2FuYXJ5VGVzdE1ldHJpY3NPdmVycmlkZSc7XG5pbXBvcnQgeyBJQ29udHJpYnV0b3JJbnNpZ2h0UnVsZURldGFpbHMgfSBmcm9tICcuL0lDb250cmlidXRvckluc2lnaHRSdWxlRGV0YWlscyc7XG5pbXBvcnQgeyBJT3BlcmF0aW9uIH0gZnJvbSAnLi9JT3BlcmF0aW9uJztcbmltcG9ydCB7IElPcGVyYXRpb25NZXRyaWNEZXRhaWxzIH0gZnJvbSAnLi9JT3BlcmF0aW9uTWV0cmljRGV0YWlscyc7XG5pbXBvcnQgeyBJU2VydmljZSB9IGZyb20gJy4vSVNlcnZpY2UnO1xuaW1wb3J0IHsgT3BlcmF0aW9uUHJvcHMgfSBmcm9tICcuL3Byb3BzL09wZXJhdGlvblByb3BzJztcbmltcG9ydCB7IEFkZENhbmFyeVRlc3RQcm9wcyB9IGZyb20gJy4uL2NhbmFyaWVzL3Byb3BzL0FkZENhbmFyeVRlc3RQcm9wcyc7XG5cbi8qKlxuICogQSBzaW5nbGUgb3BlcmF0aW9uIHRoYXQgaXMgcGFydCBvZiBhIHNlcnZpY2VcbiAqL1xuZXhwb3J0IGNsYXNzIE9wZXJhdGlvbiBpbXBsZW1lbnRzIElPcGVyYXRpb24ge1xuICAvKipcbiAgICogVGhlIHNlcnZpY2UgdGhlIG9wZXJhdGlvbiBpcyBhc3NvY2lhdGVkIHdpdGhcbiAgICovXG4gIHJlYWRvbmx5IHNlcnZpY2U6IElTZXJ2aWNlO1xuXG4gIC8qKlxuICAgKiBUaGUgbmFtZSBvZiB0aGUgb3BlcmF0aW9uXG4gICAqL1xuICByZWFkb25seSBvcGVyYXRpb25OYW1lOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqICBUaGUgSFRUUCBwYXRoIGZvciB0aGUgb3BlcmF0aW9uIGZvciBjYW5hcmllc1xuICAgKiAgdG8gcnVuIGFnYWluc3QsIHNvbWV0aGluZyBsaWtlIFwiL3Byb2R1Y3RzL2xpc3RcIlxuICAgKi9cbiAgcmVhZG9ubHkgcGF0aDogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgc2VydmVyIHNpZGUgYXZhaWxhYmlsaXR5IG1ldHJpYyBkZXRhaWxzXG4gICAqL1xuICByZWFkb25seSBzZXJ2ZXJTaWRlQXZhaWxhYmlsaXR5TWV0cmljRGV0YWlsczogSU9wZXJhdGlvbk1ldHJpY0RldGFpbHM7XG5cbiAgLyoqXG4gICAqIFRoZSBzZXJ2ZXIgc2lkZSBsYXRlbmN5IG1ldHJpYyBkZXRhaWxzXG4gICAqL1xuICByZWFkb25seSBzZXJ2ZXJTaWRlTGF0ZW5jeU1ldHJpY0RldGFpbHM6IElPcGVyYXRpb25NZXRyaWNEZXRhaWxzO1xuXG4gIC8qKlxuICAgKiBPcHRpb25hbCBtZXRyaWMgZGV0YWlscyBpZiB0aGUgc2VydmljZSBoYXMgYSBjYW5hcnlcbiAgICovXG4gIHJlYWRvbmx5IGNhbmFyeU1ldHJpY0RldGFpbHM/OiBJQ2FuYXJ5TWV0cmljcztcblxuICAvKipcbiAgICogVGhlIG92ZXJyaWRlIHZhbHVlcyBmb3IgYXV0b21hdGljYWxseSBjcmVhdGVkIGNhbmFyeSB0ZXN0cyBzbyB5b3UgY2FuXG4gICAqIHVzZSB2YWx1ZXMgb3RoZXIgdGhhbiB0aGUgc2VydmljZSBkZWZhdWx0cyB0byBkZWZpbmUgdGhlIHRocmVzaG9sZHMgZm9yXG4gICAqIGF2YWlsYWJpbGl0eS5cbiAgICovXG4gIHJlYWRvbmx5IGNhbmFyeVRlc3RBdmFpbGFiaWxpdHlNZXRyaWNzT3ZlcnJpZGU/OiBJQ2FuYXJ5VGVzdE1ldHJpY3NPdmVycmlkZTtcblxuICAvKipcbiAgICogVGhlIG92ZXJyaWRlIHZhbHVlcyBmb3IgYXV0b21hdGljYWxseSBjcmVhdGVkIGNhbmFyeSB0ZXN0cyBzbyB5b3UgY2FuXG4gICAqIHVzZSB2YWx1ZXMgb3RoZXIgdGhhbiB0aGUgc2VydmljZSBkZWZhdWx0cyB0byBkZWZpbmUgdGhlIHRocmVzaG9sZHMgZm9yXG4gICAqIGxhdGVuY3kuXG4gICAqL1xuICByZWFkb25seSBjYW5hcnlUZXN0TGF0ZW5jeU1ldHJpY3NPdmVycmlkZT86IElDYW5hcnlUZXN0TWV0cmljc092ZXJyaWRlO1xuXG4gIC8qKlxuICAgKiBUaGUgc2VydmVyIHNpZGUgZGV0YWlscyBmb3IgY29udHJpYnV0b3IgaW5zaWdodHMgcnVsZXNcbiAgICovXG4gIHJlYWRvbmx5IHNlcnZlclNpZGVDb250cmlidXRvckluc2lnaHRSdWxlRGV0YWlscz86IElDb250cmlidXRvckluc2lnaHRSdWxlRGV0YWlscztcblxuICAvKipcbiAgICogSW5kaWNhdGVzIHRoaXMgaXMgYSBjcml0aWNhbCBvcGVyYXRpb24gZm9yIHRoZSBzZXJ2aWNlXG4gICAqIGFuZCB3aWxsIGJlIGluY2x1ZGVkIGluIHNlcnZpY2UgbGV2ZWwgbWV0cmljcyBhbmRcbiAgICogZGFzaGJvYXJkc1xuICAgKi9cbiAgcmVhZG9ubHkgY3JpdGljYWw6IGJvb2xlYW47XG5cbiAgLyoqXG4gICAqIFRoZSBodHRwIG1ldGhvZHMgc3VwcG9ydGVkIGJ5IHRoZSBvcGVyYXRpb25cbiAgICovXG4gIHJlYWRvbmx5IGh0dHBNZXRob2RzOiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogSWYgdGhleSBoYXZlIGJlZW4gYWRkZWQsIHRoZSBwcm9wZXJ0aWVzIGZvclxuICAgKiBjcmVhdGluZyBuZXcgY2FuYXJ5IHRlc3RzIG9uIHRoaXMgb3BlcmF0aW9uXG4gICAqL1xuICByZWFkb25seSBjYW5hcnlUZXN0UHJvcHM/OiBBZGRDYW5hcnlUZXN0UHJvcHM7XG5cbiAgLyoqXG4gICAqIFNldCB0byB0cnVlIGlmIHlvdSBoYXZlIGRlZmluZWQgQ2FuYXJ5VGVzdFByb3BzIGZvciB5b3VyXG4gICAqIHNlcnZpY2UsIHdoaWNoIGFwcGxpZXMgdG8gYWxsIG9wZXJhdGlvbnMsIGJ1dCB5b3Ugd2FudCB0b1xuICAgKiBvcHQgb3V0IG9mIGNyZWF0aW5nIHRoZSBjYW5hcnkgdGVzdCBmb3IgdGhpcyBvcGVyYXRpb24uXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gVGhlIG9wZXJhdGlvbiBpcyBub3Qgb3B0ZWQgb3V0XG4gICAqL1xuICByZWFkb25seSBvcHRPdXRPZlNlcnZpY2VDcmVhdGVkQ2FuYXJ5PzogYm9vbGVhbjtcblxuICBjb25zdHJ1Y3Rvcihwcm9wczogT3BlcmF0aW9uUHJvcHMpIHtcbiAgICB0aGlzLmNhbmFyeU1ldHJpY0RldGFpbHMgPSBwcm9wcy5jYW5hcnlNZXRyaWNEZXRhaWxzO1xuICAgIHRoaXMuaHR0cE1ldGhvZHMgPSBwcm9wcy5odHRwTWV0aG9kcztcbiAgICB0aGlzLmNyaXRpY2FsID0gcHJvcHMuY3JpdGljYWw7XG4gICAgdGhpcy5vcGVyYXRpb25OYW1lID0gcHJvcHMub3BlcmF0aW9uTmFtZTtcbiAgICB0aGlzLnBhdGggPSBwcm9wcy5wYXRoO1xuICAgIHRoaXMuc2VydmVyU2lkZUF2YWlsYWJpbGl0eU1ldHJpY0RldGFpbHMgPVxuICAgICAgcHJvcHMuc2VydmVyU2lkZUF2YWlsYWJpbGl0eU1ldHJpY0RldGFpbHM7XG4gICAgdGhpcy5zZXJ2ZXJTaWRlTGF0ZW5jeU1ldHJpY0RldGFpbHMgPSBwcm9wcy5zZXJ2ZXJTaWRlTGF0ZW5jeU1ldHJpY0RldGFpbHM7XG4gICAgdGhpcy5zZXJ2ZXJTaWRlQ29udHJpYnV0b3JJbnNpZ2h0UnVsZURldGFpbHMgPVxuICAgICAgcHJvcHMuc2VydmVyU2lkZUNvbnRyaWJ1dG9ySW5zaWdodFJ1bGVEZXRhaWxzO1xuICAgIHRoaXMuc2VydmljZSA9IHByb3BzLnNlcnZpY2U7XG4gICAgdGhpcy5jYW5hcnlUZXN0UHJvcHMgPSBwcm9wcy5jYW5hcnlUZXN0UHJvcHM7XG4gICAgdGhpcy5vcHRPdXRPZlNlcnZpY2VDcmVhdGVkQ2FuYXJ5ID0gcHJvcHMub3B0T3V0T2ZTZXJ2aWNlQ3JlYXRlZENhbmFyeTtcbiAgICB0aGlzLmNhbmFyeVRlc3RBdmFpbGFiaWxpdHlNZXRyaWNzT3ZlcnJpZGUgPVxuICAgICAgcHJvcHMuY2FuYXJ5VGVzdEF2YWlsYWJpbGl0eU1ldHJpY3NPdmVycmlkZTtcbiAgICB0aGlzLmNhbmFyeVRlc3RMYXRlbmN5TWV0cmljc092ZXJyaWRlID1cbiAgICAgIHByb3BzLmNhbmFyeVRlc3RMYXRlbmN5TWV0cmljc092ZXJyaWRlO1xuICAgIHRoaXMub3B0T3V0T2ZTZXJ2aWNlQ3JlYXRlZENhbmFyeSA9IHByb3BzLm9wdE91dE9mU2VydmljZUNyZWF0ZWRDYW5hcnk7XG4gIH1cbn1cbiJdfQ==

package/lib/services/OperationMetricDetails.d.ts

@@ -0,0 +1,82 @@
+import { Duration } from 'aws-cdk-lib';
+import { Unit } from 'aws-cdk-lib/aws-cloudwatch';
+import { IOperationMetricDetails } from './IOperationMetricDetails';
+import { IServiceMetricDetails } from './IServiceMetricDetails';
+import { MetricDimensions } from './props/MetricDimensions';
+import { OperationMetricDetailsProps } from './props/OperationMetricDetailsProps';
+/**
+ * Generic metric details for an operation
+ */
+export declare class OperationMetricDetails implements IOperationMetricDetails {
+    /**
+     * The operation these metric details are for
+     */
+    readonly operationName: string;
+    /**
+     * The CloudWatch metric namespace for these metrics
+     */
+    readonly metricNamespace: string;
+    /**
+     * The names of success indicating metrics
+     */
+    readonly successMetricNames: string[];
+    /**
+     * The names of fault indicating metrics
+     */
+    readonly faultMetricNames: string[];
+    /**
+     * The statistic used for alarms, for availability metrics this should
+     * be "Sum", for latency metrics it could something like "p99" or "p99.9"
+     */
+    readonly alarmStatistic: string;
+    /**
+     * The statistics for successes you want to appear on dashboards, for example, with
+     * latency metrics, you might want p50, p99, and tm99. For availability
+     * metrics this will typically just be "Sum".
+     *
+     * @default - For availability metrics, this will be "Sum", for latency metrics it will be just "p99"
+     */
+    readonly graphedSuccessStatistics?: string[];
+    /**
+     * The statistics for faults you want to appear on dashboards, for example, with
+     * latency metrics, you might want p50, p99, and tm99. For availability
+     * metrics this will typically just be "Sum".
+     *
+     * @default - For availability metrics, this will be "Sum", for latency metrics it will be just "p99"
+     */
+    readonly graphedFaultStatistics?: string[];
+    /**
+     * The unit used for these metrics
+     */
+    readonly unit: Unit;
+    /**
+     * The period for the metrics
+     */
+    readonly period: Duration;
+    /**
+     * The number of evaluation periods for latency and availabiltiy alarms
+     */
+    readonly evaluationPeriods: number;
+    /**
+     * The number of datapoints to alarm on for latency and availability alarms
+     */
+    readonly datapointsToAlarm: number;
+    /**
+     * The threshold for alarms associated with success metrics, for example if measuring
+     * success rate, the threshold may be 99, meaning you would want an alarm that triggers
+     * if success drops below 99%.
+     */
+    readonly successAlarmThreshold: number;
+    /**
+     * The threshold for alarms associated with fault metrics, for example if measuring
+     * fault rate, the threshold may be 1, meaning you would want an alarm that triggers
+     * if the fault rate goes above 1%.
+     */
+    readonly faultAlarmThreshold: number;
+    /**
+     * The metric dimensions for this operation, must be implemented
+     * as a concrete class by the user
+     */
+    readonly metricDimensions: MetricDimensions;
+    constructor(props: OperationMetricDetailsProps, defaultProps: IServiceMetricDetails);
+}

package/lib/services/OperationMetricDetails.js

@@ -0,0 +1,50 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationMetricDetails = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Generic metric details for an operation
+ */
+class OperationMetricDetails {
+    constructor(props, defaultProps) {
+        this.alarmStatistic = props.alarmStatistic
+            ? props.alarmStatistic
+            : defaultProps.alarmStatistic;
+        this.datapointsToAlarm = props.datapointsToAlarm
+            ? props.datapointsToAlarm
+            : defaultProps.datapointsToAlarm;
+        this.evaluationPeriods = props.evaluationPeriods
+            ? props.evaluationPeriods
+            : defaultProps.evaluationPeriods;
+        this.faultAlarmThreshold = props.faultAlarmThreshold
+            ? props.faultAlarmThreshold
+            : defaultProps.faultAlarmThreshold;
+        this.faultMetricNames = props.faultMetricNames
+            ? props.faultMetricNames
+            : defaultProps.faultMetricNames;
+        this.graphedFaultStatistics = props.graphedFaultStatistics
+            ? props.graphedFaultStatistics
+            : defaultProps.graphedFaultStatistics;
+        this.graphedSuccessStatistics = props.graphedSuccessStatistics
+            ? props.graphedSuccessStatistics
+            : defaultProps.graphedSuccessStatistics;
+        this.metricNamespace = props.metricNamespace
+            ? props.metricNamespace
+            : defaultProps.metricNamespace;
+        this.operationName = props.operationName;
+        this.period = props.period ? props.period : defaultProps.period;
+        this.successAlarmThreshold = props.successAlarmThreshold
+            ? props.successAlarmThreshold
+            : defaultProps.successAlarmThreshold;
+        this.successMetricNames = props.successMetricNames
+            ? props.successMetricNames
+            : defaultProps.successMetricNames;
+        this.unit = props.unit ? props.unit : defaultProps.unit;
+        this.metricDimensions = props.metricDimensions;
+    }
+}
+exports.OperationMetricDetails = OperationMetricDetails;
+_a = JSII_RTTI_SYMBOL_1;
+OperationMetricDetails[_a] = { fqn: "@cdklabs/multi-az-observability.OperationMetricDetails", version: "0.0.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"OperationMetricDetails.js","sourceRoot":"","sources":["../../src/services/OperationMetricDetails.ts"],"names":[],"mappings":";;;;;AASA;;GAEG;AACH,MAAa,sBAAsB;IAqFjC,YACE,KAAkC,EAClC,YAAmC;QAEnC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc;YACxC,CAAC,CAAC,KAAK,CAAC,cAAc;YACtB,CAAC,CAAC,YAAY,CAAC,cAAc,CAAC;QAChC,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,iBAAiB;YAC9C,CAAC,CAAC,KAAK,CAAC,iBAAiB;YACzB,CAAC,CAAC,YAAY,CAAC,iBAAiB,CAAC;QACnC,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,iBAAiB;YAC9C,CAAC,CAAC,KAAK,CAAC,iBAAiB;YACzB,CAAC,CAAC,YAAY,CAAC,iBAAiB,CAAC;QACnC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,mBAAmB;YAClD,CAAC,CAAC,KAAK,CAAC,mBAAmB;YAC3B,CAAC,CAAC,YAAY,CAAC,mBAAmB,CAAC;QACrC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB;YAC5C,CAAC,CAAC,KAAK,CAAC,gBAAgB;YACxB,CAAC,CAAC,YAAY,CAAC,gBAAgB,CAAC;QAClC,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC,sBAAsB;YACxD,CAAC,CAAC,KAAK,CAAC,sBAAsB;YAC9B,CAAC,CAAC,YAAY,CAAC,sBAAsB,CAAC;QACxC,IAAI,CAAC,wBAAwB,GAAG,KAAK,CAAC,wBAAwB;YAC5D,CAAC,CAAC,KAAK,CAAC,wBAAwB;YAChC,CAAC,CAAC,YAAY,CAAC,wBAAwB,CAAC;QAC1C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,eAAe;YAC1C,CAAC,CAAC,KAAK,CAAC,eAAe;YACvB,CAAC,CAAC,YAAY,CAAC,eAAe,CAAC;QACjC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QACzC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC;QAChE,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC,qBAAqB;YACtD,CAAC,CAAC,KAAK,CAAC,qBAAqB;YAC7B,CAAC,CAAC,YAAY,CAAC,qBAAqB,CAAC;QACvC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB;YAChD,CAAC,CAAC,KAAK,CAAC,kBAAkB;YAC1B,CAAC,CAAC,YAAY,CAAC,kBAAkB,CAAC;QACpC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC;QACxD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC;IACjD,CAAC;;AA3HH,wDA4HC","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\nimport { Duration } from 'aws-cdk-lib';\nimport { Unit } from 'aws-cdk-lib/aws-cloudwatch';\nimport { IOperationMetricDetails } from './IOperationMetricDetails';\nimport { IServiceMetricDetails } from './IServiceMetricDetails';\nimport { MetricDimensions } from './props/MetricDimensions';\nimport { OperationMetricDetailsProps } from './props/OperationMetricDetailsProps';\n\n/**\n * Generic metric details for an operation\n */\nexport class OperationMetricDetails implements IOperationMetricDetails {\n  /**\n   * The operation these metric details are for\n   */\n  readonly operationName: string;\n\n  /**\n   * The CloudWatch metric namespace for these metrics\n   */\n  readonly metricNamespace: string;\n\n  /**\n   * The names of success indicating metrics\n   */\n  readonly successMetricNames: string[];\n\n  /**\n   * The names of fault indicating metrics\n   */\n  readonly faultMetricNames: string[];\n\n  /**\n   * The statistic used for alarms, for availability metrics this should\n   * be \"Sum\", for latency metrics it could something like \"p99\" or \"p99.9\"\n   */\n  readonly alarmStatistic: string;\n\n  /**\n   * The statistics for successes you want to appear on dashboards, for example, with\n   * latency metrics, you might want p50, p99, and tm99. For availability\n   * metrics this will typically just be \"Sum\".\n   *\n   * @default - For availability metrics, this will be \"Sum\", for latency metrics it will be just \"p99\"\n   */\n  readonly graphedSuccessStatistics?: string[];\n\n  /**\n   * The statistics for faults you want to appear on dashboards, for example, with\n   * latency metrics, you might want p50, p99, and tm99. For availability\n   * metrics this will typically just be \"Sum\".\n   *\n   * @default - For availability metrics, this will be \"Sum\", for latency metrics it will be just \"p99\"\n   */\n  readonly graphedFaultStatistics?: string[];\n\n  /**\n   * The unit used for these metrics\n   */\n  readonly unit: Unit;\n\n  /**\n   * The period for the metrics\n   */\n  readonly period: Duration;\n\n  /**\n   * The number of evaluation periods for latency and availabiltiy alarms\n   */\n  readonly evaluationPeriods: number;\n\n  /**\n   * The number of datapoints to alarm on for latency and availability alarms\n   */\n  readonly datapointsToAlarm: number;\n\n  /**\n   * The threshold for alarms associated with success metrics, for example if measuring\n   * success rate, the threshold may be 99, meaning you would want an alarm that triggers\n   * if success drops below 99%.\n   */\n  readonly successAlarmThreshold: number;\n\n  /**\n   * The threshold for alarms associated with fault metrics, for example if measuring\n   * fault rate, the threshold may be 1, meaning you would want an alarm that triggers\n   * if the fault rate goes above 1%.\n   */\n  readonly faultAlarmThreshold: number;\n\n  /**\n   * The metric dimensions for this operation, must be implemented\n   * as a concrete class by the user\n   */\n  readonly metricDimensions: MetricDimensions;\n\n  constructor(\n    props: OperationMetricDetailsProps,\n    defaultProps: IServiceMetricDetails,\n  ) {\n    this.alarmStatistic = props.alarmStatistic\n      ? props.alarmStatistic\n      : defaultProps.alarmStatistic;\n    this.datapointsToAlarm = props.datapointsToAlarm\n      ? props.datapointsToAlarm\n      : defaultProps.datapointsToAlarm;\n    this.evaluationPeriods = props.evaluationPeriods\n      ? props.evaluationPeriods\n      : defaultProps.evaluationPeriods;\n    this.faultAlarmThreshold = props.faultAlarmThreshold\n      ? props.faultAlarmThreshold\n      : defaultProps.faultAlarmThreshold;\n    this.faultMetricNames = props.faultMetricNames\n      ? props.faultMetricNames\n      : defaultProps.faultMetricNames;\n    this.graphedFaultStatistics = props.graphedFaultStatistics\n      ? props.graphedFaultStatistics\n      : defaultProps.graphedFaultStatistics;\n    this.graphedSuccessStatistics = props.graphedSuccessStatistics\n      ? props.graphedSuccessStatistics\n      : defaultProps.graphedSuccessStatistics;\n    this.metricNamespace = props.metricNamespace\n      ? props.metricNamespace\n      : defaultProps.metricNamespace;\n    this.operationName = props.operationName;\n    this.period = props.period ? props.period : defaultProps.period;\n    this.successAlarmThreshold = props.successAlarmThreshold\n      ? props.successAlarmThreshold\n      : defaultProps.successAlarmThreshold;\n    this.successMetricNames = props.successMetricNames\n      ? props.successMetricNames\n      : defaultProps.successMetricNames;\n    this.unit = props.unit ? props.unit : defaultProps.unit;\n    this.metricDimensions = props.metricDimensions;\n  }\n}\n"]}

package/lib/services/Service.d.ts

@@ -0,0 +1,80 @@
+import { Duration } from 'aws-cdk-lib';
+import { ILoadBalancerV2 } from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import { IContributorInsightRuleDetails } from './IContributorInsightRuleDetails';
+import { IOperation } from './IOperation';
+import { IService } from './IService';
+import { IServiceMetricDetails } from './IServiceMetricDetails';
+import { ServiceProps } from './props/ServiceProps';
+import { AddCanaryTestProps } from '../canaries/props/AddCanaryTestProps';
+/**
+ * The representation of a service composed of multiple operations
+ */
+export declare class Service implements IService {
+    /**
+     * The name of your service
+     */
+    readonly serviceName: string;
+    /**
+     * The base endpoint for this service, like "https://www.example.com". Operation paths will be appended to this endpoint for canary testing the service.
+     */
+    readonly baseUrl: string;
+    /**
+     * The fault count threshold that indicates the service is unhealthy. This is an absolute value of faults
+     * being produced by all critical operations in aggregate.
+     */
+    readonly faultCountThreshold: number;
+    /**
+     * A list of the Availability Zone names used by this application
+     */
+    readonly availabilityZoneNames: string[];
+    /**
+     * The period for which metrics for the service should be aggregated
+     */
+    readonly period: Duration;
+    /**
+     * The operations that are part of this service
+     */
+    readonly operations: IOperation[];
+    /**
+     * The load balancer this service sits behind
+     *
+     * @default - No load balancer metrics will be included in
+     * dashboards and its ARN will not be added to top level AZ
+     * alarm descriptions.
+     */
+    readonly loadBalancer?: ILoadBalancerV2;
+    /**
+     * Define these settings if you want to automatically add canary
+     * tests to your operations. Operations can individually opt out
+     * of canary test creation if you define this setting.
+     *
+     * @default - Automatic canary tests will not be created for
+     * operations in this service.
+     */
+    readonly canaryTestProps?: AddCanaryTestProps;
+    /**
+     * The default settings that are used for availability metrics
+     * for all operations unless specifically overridden in an
+     * operation definition.
+     */
+    readonly defaultAvailabilityMetricDetails: IServiceMetricDetails;
+    /**
+     * The default settings that are used for availability metrics
+     * for all operations unless specifically overridden in an
+     * operation definition.
+     */
+    readonly defaultLatencyMetricDetails: IServiceMetricDetails;
+    /**
+     * The default settings that are used for contributor insight
+     * rules.
+     *
+     * @default - No defaults are provided and must be specified per operation
+     */
+    readonly defaultContributorInsightRuleDetails?: IContributorInsightRuleDetails;
+    constructor(props: ServiceProps);
+    /**
+     * Adds an operation to this service and sets the operation's
+     * service property
+     */
+    addOperation(operation: IOperation): void;
+}

package/lib/services/Service.js

@@ -0,0 +1,36 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * The representation of a service composed of multiple operations
+ */
+class Service {
+    constructor(props) {
+        this.serviceName = props.serviceName;
+        this.availabilityZoneNames = props.availabilityZoneNames;
+        this.baseUrl = props.baseUrl;
+        this.faultCountThreshold = props.faultCountThreshold;
+        this.operations = [];
+        this.period = props.period;
+        this.loadBalancer = props.loadBalancer;
+        this.canaryTestProps = props.canaryTestProps;
+        this.defaultAvailabilityMetricDetails =
+            props.defaultAvailabilityMetricDetails;
+        this.defaultLatencyMetricDetails = props.defaultLatencyMetricDetails;
+        this.defaultContributorInsightRuleDetails =
+            props.defaultContributorInsightRuleDetails;
+    }
+    /**
+     * Adds an operation to this service and sets the operation's
+     * service property
+     */
+    addOperation(operation) {
+        this.operations.push(operation);
+    }
+}
+exports.Service = Service;
+_a = JSII_RTTI_SYMBOL_1;
+Service[_a] = { fqn: "@cdklabs/multi-az-observability.Service", version: "0.0.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/ServiceMetricDetails.d.ts

@@ -0,0 +1,71 @@
+import { Duration } from 'aws-cdk-lib';
+import { Unit } from 'aws-cdk-lib/aws-cloudwatch';
+import { IServiceMetricDetails } from './IServiceMetricDetails';
+import { ServiceMetricDetailsProps } from './props/ServiceMetricDetailsProps';
+/**
+ * Default metric details for a service
+ */
+export declare class ServiceMetricDetails implements IServiceMetricDetails {
+    /**
+     * The CloudWatch metric namespace for these metrics
+     */
+    readonly metricNamespace: string;
+    /**
+     * The names of success indicating metrics
+     */
+    readonly successMetricNames: string[];
+    /**
+     * The names of fault indicating metrics
+     */
+    readonly faultMetricNames: string[];
+    /**
+     * The statistic used for alarms, for availability metrics this should
+     * be "Sum", for latency metrics it could something like "p99" or "p99.9"
+     */
+    readonly alarmStatistic: string;
+    /**
+     * The statistics for successes you want to appear on dashboards, for example, with
+     * latency metrics, you might want p50, p99, and tm99. For availability
+     * metrics this will typically just be "Sum".
+     *
+     * @default - For availability metrics, this will be "Sum", for latency metrics it will be just "p99"
+     */
+    readonly graphedSuccessStatistics?: string[];
+    /**
+     * The statistics for faults you want to appear on dashboards, for example, with
+     * latency metrics, you might want p50, p99, and tm99. For availability
+     * metrics this will typically just be "Sum".
+     *
+     * @default - For availability metrics, this will be "Sum", for latency metrics it will be just "p99"
+     */
+    readonly graphedFaultStatistics?: string[];
+    /**
+     * The unit used for these metrics
+     */
+    readonly unit: Unit;
+    /**
+     * The period for the metrics
+     */
+    readonly period: Duration;
+    /**
+     * The number of evaluation periods for latency and availabiltiy alarms
+     */
+    readonly evaluationPeriods: number;
+    /**
+     * The number of datapoints to alarm on for latency and availability alarms
+     */
+    readonly datapointsToAlarm: number;
+    /**
+     * The threshold for alarms associated with success metrics, for example if measuring
+     * success rate, the threshold may be 99, meaning you would want an alarm that triggers
+     * if success drops below 99%.
+     */
+    readonly successAlarmThreshold: number;
+    /**
+     * The threshold for alarms associated with fault metrics, for example if measuring
+     * fault rate, the threshold may be 1, meaning you would want an alarm that triggers
+     * if the fault rate goes above 1%.
+     */
+    readonly faultAlarmThreshold: number;
+    constructor(props: ServiceMetricDetailsProps);
+}

package/lib/services/ServiceMetricDetails.js

@@ -0,0 +1,28 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceMetricDetails = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Default metric details for a service
+ */
+class ServiceMetricDetails {
+    constructor(props) {
+        this.alarmStatistic = props.alarmStatistic;
+        this.datapointsToAlarm = props.datapointsToAlarm;
+        this.evaluationPeriods = props.evaluationPeriods;
+        this.faultAlarmThreshold = props.faultAlarmThreshold;
+        this.faultMetricNames = props.faultMetricNames;
+        this.graphedFaultStatistics = props.graphedFaultStatistics;
+        this.graphedSuccessStatistics = props.graphedSuccessStatistics;
+        this.metricNamespace = props.metricNamespace;
+        this.period = props.period;
+        this.successAlarmThreshold = props.successAlarmThreshold;
+        this.successMetricNames = props.successMetricNames;
+        this.unit = props.unit;
+    }
+}
+exports.ServiceMetricDetails = ServiceMetricDetails;
+_a = JSII_RTTI_SYMBOL_1;
+ServiceMetricDetails[_a] = { fqn: "@cdklabs/multi-az-observability.ServiceMetricDetails", version: "0.0.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VydmljZU1ldHJpY0RldGFpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvU2VydmljZU1ldHJpY0RldGFpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFPQTs7R0FFRztBQUNILE1BQWEsb0JBQW9CO0lBMEUvQixZQUFZLEtBQWdDO1FBQzFDLElBQUksQ0FBQyxjQUFjLEdBQUcsS0FBSyxDQUFDLGNBQWMsQ0FBQztRQUMzQyxJQUFJLENBQUMsaUJBQWlCLEdBQUcsS0FBSyxDQUFDLGlCQUFpQixDQUFDO1FBQ2pELElBQUksQ0FBQyxpQkFBaUIsR0FBRyxLQUFLLENBQUMsaUJBQWlCLENBQUM7UUFDakQsSUFBSSxDQUFDLG1CQUFtQixHQUFHLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQztRQUNyRCxJQUFJLENBQUMsZ0JBQWdCLEdBQUcsS0FBSyxDQUFDLGdCQUFnQixDQUFDO1FBQy9DLElBQUksQ0FBQyxzQkFBc0IsR0FBRyxLQUFLLENBQUMsc0JBQXNCLENBQUM7UUFDM0QsSUFBSSxDQUFDLHdCQUF3QixHQUFHLEtBQUssQ0FBQyx3QkFBd0IsQ0FBQztRQUMvRCxJQUFJLENBQUMsZUFBZSxHQUFHLEtBQUssQ0FBQyxlQUFlLENBQUM7UUFDN0MsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDO1FBQzNCLElBQUksQ0FBQyxxQkFBcUIsR0FBRyxLQUFLLENBQUMscUJBQXFCLENBQUM7UUFDekQsSUFBSSxDQUFDLGtCQUFrQixHQUFHLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQztRQUNuRCxJQUFJLENBQUMsSUFBSSxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUM7SUFDekIsQ0FBQzs7QUF2Rkgsb0RBd0ZDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IEFtYXpvbi5jb20sIEluYy4gb3IgaXRzIGFmZmlsaWF0ZXMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuaW1wb3J0IHsgRHVyYXRpb24gfSBmcm9tICdhd3MtY2RrLWxpYic7XG5pbXBvcnQgeyBVbml0IH0gZnJvbSAnYXdzLWNkay1saWIvYXdzLWNsb3Vkd2F0Y2gnO1xuaW1wb3J0IHsgSVNlcnZpY2VNZXRyaWNEZXRhaWxzIH0gZnJvbSAnLi9JU2VydmljZU1ldHJpY0RldGFpbHMnO1xuaW1wb3J0IHsgU2VydmljZU1ldHJpY0RldGFpbHNQcm9wcyB9IGZyb20gJy4vcHJvcHMvU2VydmljZU1ldHJpY0RldGFpbHNQcm9wcyc7XG5cbi8qKlxuICogRGVmYXVsdCBtZXRyaWMgZGV0YWlscyBmb3IgYSBzZXJ2aWNlXG4gKi9cbmV4cG9ydCBjbGFzcyBTZXJ2aWNlTWV0cmljRGV0YWlscyBpbXBsZW1lbnRzIElTZXJ2aWNlTWV0cmljRGV0YWlscyB7XG4gIC8qKlxuICAgKiBUaGUgQ2xvdWRXYXRjaCBtZXRyaWMgbmFtZXNwYWNlIGZvciB0aGVzZSBtZXRyaWNzXG4gICAqL1xuICByZWFkb25seSBtZXRyaWNOYW1lc3BhY2U6IHN0cmluZztcblxuICAvKipcbiAgICogVGhlIG5hbWVzIG9mIHN1Y2Nlc3MgaW5kaWNhdGluZyBtZXRyaWNzXG4gICAqL1xuICByZWFkb25seSBzdWNjZXNzTWV0cmljTmFtZXM6IHN0cmluZ1tdO1xuXG4gIC8qKlxuICAgKiBUaGUgbmFtZXMgb2YgZmF1bHQgaW5kaWNhdGluZyBtZXRyaWNzXG4gICAqL1xuICByZWFkb25seSBmYXVsdE1ldHJpY05hbWVzOiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogVGhlIHN0YXRpc3RpYyB1c2VkIGZvciBhbGFybXMsIGZvciBhdmFpbGFiaWxpdHkgbWV0cmljcyB0aGlzIHNob3VsZFxuICAgKiBiZSBcIlN1bVwiLCBmb3IgbGF0ZW5jeSBtZXRyaWNzIGl0IGNvdWxkIHNvbWV0aGluZyBsaWtlIFwicDk5XCIgb3IgXCJwOTkuOVwiXG4gICAqL1xuICByZWFkb25seSBhbGFybVN0YXRpc3RpYzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgc3RhdGlzdGljcyBmb3Igc3VjY2Vzc2VzIHlvdSB3YW50IHRvIGFwcGVhciBvbiBkYXNoYm9hcmRzLCBmb3IgZXhhbXBsZSwgd2l0aFxuICAgKiBsYXRlbmN5IG1ldHJpY3MsIHlvdSBtaWdodCB3YW50IHA1MCwgcDk5LCBhbmQgdG05OS4gRm9yIGF2YWlsYWJpbGl0eVxuICAgKiBtZXRyaWNzIHRoaXMgd2lsbCB0eXBpY2FsbHkganVzdCBiZSBcIlN1bVwiLlxuICAgKlxuICAgKiBAZGVmYXVsdCAtIEZvciBhdmFpbGFiaWxpdHkgbWV0cmljcywgdGhpcyB3aWxsIGJlIFwiU3VtXCIsIGZvciBsYXRlbmN5IG1ldHJpY3MgaXQgd2lsbCBiZSBqdXN0IFwicDk5XCJcbiAgICovXG4gIHJlYWRvbmx5IGdyYXBoZWRTdWNjZXNzU3RhdGlzdGljcz86IHN0cmluZ1tdO1xuXG4gIC8qKlxuICAgKiBUaGUgc3RhdGlzdGljcyBmb3IgZmF1bHRzIHlvdSB3YW50IHRvIGFwcGVhciBvbiBkYXNoYm9hcmRzLCBmb3IgZXhhbXBsZSwgd2l0aFxuICAgKiBsYXRlbmN5IG1ldHJpY3MsIHlvdSBtaWdodCB3YW50IHA1MCwgcDk5LCBhbmQgdG05OS4gRm9yIGF2YWlsYWJpbGl0eVxuICAgKiBtZXRyaWNzIHRoaXMgd2lsbCB0eXBpY2FsbHkganVzdCBiZSBcIlN1bVwiLlxuICAgKlxuICAgKiBAZGVmYXVsdCAtIEZvciBhdmFpbGFiaWxpdHkgbWV0cmljcywgdGhpcyB3aWxsIGJlIFwiU3VtXCIsIGZvciBsYXRlbmN5IG1ldHJpY3MgaXQgd2lsbCBiZSBqdXN0IFwicDk5XCJcbiAgICovXG4gIHJlYWRvbmx5IGdyYXBoZWRGYXVsdFN0YXRpc3RpY3M/OiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogVGhlIHVuaXQgdXNlZCBmb3IgdGhlc2UgbWV0cmljc1xuICAgKi9cbiAgcmVhZG9ubHkgdW5pdDogVW5pdDtcblxuICAvKipcbiAgICogVGhlIHBlcmlvZCBmb3IgdGhlIG1ldHJpY3NcbiAgICovXG4gIHJlYWRvbmx5IHBlcmlvZDogRHVyYXRpb247XG5cbiAgLyoqXG4gICAqIFRoZSBudW1iZXIgb2YgZXZhbHVhdGlvbiBwZXJpb2RzIGZvciBsYXRlbmN5IGFuZCBhdmFpbGFiaWx0aXkgYWxhcm1zXG4gICAqL1xuICByZWFkb25seSBldmFsdWF0aW9uUGVyaW9kczogbnVtYmVyO1xuXG4gIC8qKlxuICAgKiBUaGUgbnVtYmVyIG9mIGRhdGFwb2ludHMgdG8gYWxhcm0gb24gZm9yIGxhdGVuY3kgYW5kIGF2YWlsYWJpbGl0eSBhbGFybXNcbiAgICovXG4gIHJlYWRvbmx5IGRhdGFwb2ludHNUb0FsYXJtOiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSB0aHJlc2hvbGQgZm9yIGFsYXJtcyBhc3NvY2lhdGVkIHdpdGggc3VjY2VzcyBtZXRyaWNzLCBmb3IgZXhhbXBsZSBpZiBtZWFzdXJpbmdcbiAgICogc3VjY2VzcyByYXRlLCB0aGUgdGhyZXNob2xkIG1heSBiZSA5OSwgbWVhbmluZyB5b3Ugd291bGQgd2FudCBhbiBhbGFybSB0aGF0IHRyaWdnZXJzXG4gICAqIGlmIHN1Y2Nlc3MgZHJvcHMgYmVsb3cgOTklLlxuICAgKi9cbiAgcmVhZG9ubHkgc3VjY2Vzc0FsYXJtVGhyZXNob2xkOiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSB0aHJlc2hvbGQgZm9yIGFsYXJtcyBhc3NvY2lhdGVkIHdpdGggZmF1bHQgbWV0cmljcywgZm9yIGV4YW1wbGUgaWYgbWVhc3VyaW5nXG4gICAqIGZhdWx0IHJhdGUsIHRoZSB0aHJlc2hvbGQgbWF5IGJlIDEsIG1lYW5pbmcgeW91IHdvdWxkIHdhbnQgYW4gYWxhcm0gdGhhdCB0cmlnZ2Vyc1xuICAgKiBpZiB0aGUgZmF1bHQgcmF0ZSBnb2VzIGFib3ZlIDElLlxuICAgKi9cbiAgcmVhZG9ubHkgZmF1bHRBbGFybVRocmVzaG9sZDogbnVtYmVyO1xuXG4gIGNvbnN0cnVjdG9yKHByb3BzOiBTZXJ2aWNlTWV0cmljRGV0YWlsc1Byb3BzKSB7XG4gICAgdGhpcy5hbGFybVN0YXRpc3RpYyA9IHByb3BzLmFsYXJtU3RhdGlzdGljO1xuICAgIHRoaXMuZGF0YXBvaW50c1RvQWxhcm0gPSBwcm9wcy5kYXRhcG9pbnRzVG9BbGFybTtcbiAgICB0aGlzLmV2YWx1YXRpb25QZXJpb2RzID0gcHJvcHMuZXZhbHVhdGlvblBlcmlvZHM7XG4gICAgdGhpcy5mYXVsdEFsYXJtVGhyZXNob2xkID0gcHJvcHMuZmF1bHRBbGFybVRocmVzaG9sZDtcbiAgICB0aGlzLmZhdWx0TWV0cmljTmFtZXMgPSBwcm9wcy5mYXVsdE1ldHJpY05hbWVzO1xuICAgIHRoaXMuZ3JhcGhlZEZhdWx0U3RhdGlzdGljcyA9IHByb3BzLmdyYXBoZWRGYXVsdFN0YXRpc3RpY3M7XG4gICAgdGhpcy5ncmFwaGVkU3VjY2Vzc1N0YXRpc3RpY3MgPSBwcm9wcy5ncmFwaGVkU3VjY2Vzc1N0YXRpc3RpY3M7XG4gICAgdGhpcy5tZXRyaWNOYW1lc3BhY2UgPSBwcm9wcy5tZXRyaWNOYW1lc3BhY2U7XG4gICAgdGhpcy5wZXJpb2QgPSBwcm9wcy5wZXJpb2Q7XG4gICAgdGhpcy5zdWNjZXNzQWxhcm1UaHJlc2hvbGQgPSBwcm9wcy5zdWNjZXNzQWxhcm1UaHJlc2hvbGQ7XG4gICAgdGhpcy5zdWNjZXNzTWV0cmljTmFtZXMgPSBwcm9wcy5zdWNjZXNzTWV0cmljTmFtZXM7XG4gICAgdGhpcy51bml0ID0gcHJvcHMudW5pdDtcbiAgfVxufVxuIl19

package/lib/services/props/BasicServiceMultiAZObservabilityProps.d.ts

@@ -0,0 +1,126 @@
+import { Duration } from 'aws-cdk-lib';
+import { CfnNatGateway } from 'aws-cdk-lib/aws-ec2';
+import { IApplicationLoadBalancer } from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import { OutlierDetectionAlgorithm } from '../../utilities/OutlierDetectionAlgorithm';
+/**
+ * Properties for creating a basic service
+ */
+export interface BasicServiceMultiAZObservabilityProps {
+    /**
+     * (Optional) A map of Availability Zone name to the NAT Gateways
+     * in that AZ
+     *
+     * @default - No alarms for NAT Gateways will be created
+     */
+    readonly natGateways?: {
+        [key: string]: CfnNatGateway[];
+    };
+    /**
+     * The application load balancers being used by the service
+     *
+     * @default - No alarms for ALBs will be created
+     */
+    readonly applicationLoadBalancers?: IApplicationLoadBalancer[];
+    /**
+     * The service's name
+     */
+    readonly serviceName: string;
+    /**
+     * The outlier threshold for determining if an AZ is an
+     * outlier for latency or faults. This number is interpreted
+     * differently for different outlier algorithms. When used with
+     * STATIC, the number should be between 0 and 1 to represent the
+     * percentage of errors (like .7) that an AZ must be responsible
+     * for to be considered an outlier. When used with CHI_SQUARED, it
+     * represents the p value that indicates statistical significance, like
+     * 0.05 which means the skew has less than or equal to a 5% chance of
+     * occuring. When used with Z_SCORE it indicates how many standard
+     * deviations to evaluate for an AZ being an outlier, typically 3 is
+     * standard for Z_SCORE.
+     *
+     * Standard defaults based on the outlier detection algorithm:
+     * STATIC: 0.7
+     * CHI_SQUARED: 0.05
+     * Z_SCORE: 2
+     * IQR: 1.5
+     * MAD: 3
+     *
+     * @default - Depends on the outlier detection algorithm selected
+     */
+    readonly outlierThreshold?: number;
+    /**
+     * The amount of packet loss in a NAT GW to determine if an AZ
+     * is actually impacted, recommendation is 0.01%
+     *
+     * @default - 0.01 (as in 0.01%)
+     */
+    readonly packetLossImpactPercentageThreshold?: number;
+    /**
+     * The percentage of faults for a single ALB to consider an AZ
+     * to be unhealthy, this should align with your availability goal. For example
+     * 1% or 5%.
+     *
+     * @default - 5 (as in 5%)
+     */
+    readonly faultCountPercentageThreshold?: number;
+    /**
+     * The algorithm to use for performing outlier detection
+     */
+    readonly outlierDetectionAlgorithm: OutlierDetectionAlgorithm;
+    /**
+     * The period to evaluate metrics
+     */
+    readonly period: Duration;
+    /**
+     * Whether to create a dashboard displaying the metrics and alarms
+     */
+    readonly createDashboard: boolean;
+    /**
+     * Dashboard interval
+     *
+     * @default - 1 hour
+     */
+    readonly interval?: Duration;
+    /**
+     * If you are not using a static bucket to deploy assets, for example
+     * you are synthing this and it gets uploaded to a bucket whose name
+     * is unknown to you (maybe used as part of a central CI/CD system)
+     * and is provided as a parameter to your stack, specify that parameter
+     * name here. It will override the bucket location CDK provides by
+     * default for bundled assets. The stack containing this contruct needs
+     * to have a parameter defined that uses this name. The underlying
+     * stacks in this construct that deploy assets will copy the parent stack's
+     * value for this property.
+     *
+     * @default - The assets will be uploaded to the default defined
+     * asset location.
+     */
+    readonly assetsBucketParameterName?: string;
+    /**
+     * If you are not using a static bucket to deploy assets, for example
+     * you are synthing this and it gets uploaded to a bucket that uses a prefix
+     * that is unknown to you (maybe used as part of a central CI/CD system)
+     * and is provided as a parameter to your stack, specify that parameter
+     * name here. It will override the bucket prefix CDK provides by
+     * default for bundled assets. This property only takes effect if you
+     * defined the assetsBucketParameterName. The stack containing this contruct needs
+     * to have a parameter defined that uses this name. The underlying
+     * stacks in this construct that deploy assets will copy the parent stack's
+     * value for this property.
+     *
+     * @default - No object prefix will be added to your custom assets location.
+     * However, if you have overridden something like the 'BucketPrefix' property
+     * in your stack synthesizer with a variable like "${AssetsBucketPrefix",
+     * you will need to define this property so it doesn't cause a reference error
+     * even if the prefix value is blank.
+     */
+    readonly assetsBucketPrefixParameterName?: string;
+    /**
+     * The number of evaluation periods for latency and availabiltiy alarms
+     */
+    readonly evaluationPeriods: number;
+    /**
+     * The number of datapoints to alarm on for latency and availability alarms
+     */
+    readonly datapointsToAlarm: number;
+}