@aws-cdk/metrics-facade-alpha 2.261.0-alpha.0

package/lib/services/aws-redshift/metrics.generated.js

@@ -0,0 +1,911 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedshiftMetrics = void 0;
+/* eslint-disable @stylistic/max-len, eol-last */
+const cloudwatch = __importStar(require("aws-cdk-lib/aws-cloudwatch"));
+/**
+ * CloudWatch metrics facade for AWS/Redshift
+ * This class contains helper functions to initialize the dimension-sets classes
+ * for selected resources if available.
+ *
+ * @stability external
+ */
+class RedshiftMetrics {
+    /**
+     * Create ClusterMetrics from a Cluster reference
+     */
+    static fromCluster(ref) {
+        return new RedshiftMetrics.ClusterMetrics({
+            clusterIdentifier: ref.clusterRef.clusterIdentifier
+        });
+    }
+}
+exports.RedshiftMetrics = RedshiftMetrics;
+(function (RedshiftMetrics) {
+    /**
+     * Metrics for dimension set: Cluster {ClusterIdentifier}
+     *
+     * @stability external
+     */
+    class ClusterMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier
+            };
+        }
+        /**
+         * Average of the CommitQueueLength metric
+         *
+         * @default - Average over 5 minutes
+         */
+        commitQueueLength(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "CommitQueueLength",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the ConcurrencyScalingActiveClusters metric
+         *
+         * @default - Average over 5 minutes
+         */
+        concurrencyScalingActiveClusters(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "ConcurrencyScalingActiveClusters",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the ConcurrencyScalingSeconds metric
+         *
+         * @default - Average over 5 minutes
+         */
+        concurrencyScalingSeconds(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "ConcurrencyScalingSeconds",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the CPUUtilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "CPUUtilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DatabaseConnections metric
+         *
+         * @default - Average over 5 minutes
+         */
+        databaseConnections(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "DatabaseConnections",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the HealthStatus metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        healthStatus(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "HealthStatus",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the MaintenanceMode metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        maintenanceMode(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "MaintenanceMode",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the MaxConfiguredConcurrencyScalingClusters metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        maxConfiguredConcurrencyScalingClusters(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "MaxConfiguredConcurrencyScalingClusters",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the NetworkReceiveThroughput metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        networkReceiveThroughput(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "NetworkReceiveThroughput",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the NetworkTransmitThroughput metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        networkTransmitThroughput(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "NetworkTransmitThroughput",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the NumExceededSchemaQuotas metric
+         *
+         * @default - Average over 5 minutes
+         */
+        numExceededSchemaQuotas(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "NumExceededSchemaQuotas",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the PercentageDiskSpaceUsed metric
+         *
+         * @default - Average over 5 minutes
+         */
+        percentageDiskSpaceUsed(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "PercentageDiskSpaceUsed",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ReadIOPS metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        readIops(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "ReadIOPS",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the ReadLatency metric
+         *
+         * @default - Average over 5 minutes
+         */
+        readLatency(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "ReadLatency",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ReadThroughput metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        readThroughput(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "ReadThroughput",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the RedshiftManagedStorageTotalCapacity metric
+         *
+         * @default - Average over 5 minutes
+         */
+        redshiftManagedStorageTotalCapacity(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "RedshiftManagedStorageTotalCapacity",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the TotalTableCount metric
+         *
+         * @default - Average over 5 minutes
+         */
+        totalTableCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "TotalTableCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMQueueLength metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueueLength(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueueLength",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the WriteIOPS metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        writeIops(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WriteIOPS",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the WriteLatency metric
+         *
+         * @default - Average over 5 minutes
+         */
+        writeLatency(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WriteLatency",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the WriteThroughput metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        writeThroughput(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WriteThroughput",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.ClusterMetrics = ClusterMetrics;
+    /**
+     * Metrics for dimension set: Node {ClusterIdentifier, NodeID}
+     *
+     * @stability external
+     */
+    class NodeMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                NodeID: props.nodeId
+            };
+        }
+        /**
+         * Average of the CPUUtilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "CPUUtilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the ReadLatency metric
+         *
+         * @default - Average over 5 minutes
+         */
+        readLatency(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "ReadLatency",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WriteLatency metric
+         *
+         * @default - Average over 5 minutes
+         */
+        writeLatency(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WriteLatency",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkReceiveThroughput metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkReceiveThroughput(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "NetworkReceiveThroughput",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkTransmitThroughput metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkTransmitThroughput(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "NetworkTransmitThroughput",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the ReadIOPS metric
+         *
+         * @default - Average over 5 minutes
+         */
+        readIops(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "ReadIOPS",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the ReadThroughput metric
+         *
+         * @default - Average over 5 minutes
+         */
+        readThroughput(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "ReadThroughput",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WriteIOPS metric
+         *
+         * @default - Average over 5 minutes
+         */
+        writeIops(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WriteIOPS",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WriteThroughput metric
+         *
+         * @default - Average over 5 minutes
+         */
+        writeThroughput(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WriteThroughput",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.NodeMetrics = NodeMetrics;
+    /**
+     * Metrics for dimension set: Queue {ClusterIdentifier, QueueName}
+     *
+     * @stability external
+     */
+    class QueueMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                QueueName: props.queueName
+            };
+        }
+        /**
+         * Average of the WLMQueueLength metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueueLength(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueueLength",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMQueriesCompletedPerSecond metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueriesCompletedPerSecond(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueriesCompletedPerSecond",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMQueryDuration metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueryDuration(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueryDuration",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMQueueWaitTime metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueueWaitTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueueWaitTime",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMRunningQueries metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmRunningQueries(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMRunningQueries",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.QueueMetrics = QueueMetrics;
+    /**
+     * Metrics for dimension set: ServiceClass {ClusterIdentifier, service class}
+     *
+     * @stability external
+     */
+    class ServiceClassMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                "service class": props.serviceClass
+            };
+        }
+        /**
+         * Average of the WLMQueueLength metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueueLength(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueueLength",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.ServiceClassMetrics = ServiceClassMetrics;
+    /**
+     * Metrics for dimension set: WorkloadManagement {ClusterIdentifier, wlmid}
+     *
+     * @stability external
+     */
+    class WorkloadManagementMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                wlmid: props.wlmid
+            };
+        }
+        /**
+         * Average of the WLMQueriesCompletedPerSecond metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueriesCompletedPerSecond(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueriesCompletedPerSecond",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMQueryDuration metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueryDuration(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueryDuration",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMQueueWaitTime metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueueWaitTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueueWaitTime",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMRunningQueries metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmRunningQueries(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMRunningQueries",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.WorkloadManagementMetrics = WorkloadManagementMetrics;
+    /**
+     * Metrics for dimension set: WorkloadManagementPerNode {ClusterIdentifier, wlmid, NodeID}
+     *
+     * @stability external
+     */
+    class WorkloadManagementPerNodeMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                wlmid: props.wlmid,
+                NodeID: props.nodeId
+            };
+        }
+        /**
+         * Average of the WLMQueriesCompletedPerSecond metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueriesCompletedPerSecond(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueriesCompletedPerSecond",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the WLMQueryDuration metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueryDuration(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueryDuration",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.WorkloadManagementPerNodeMetrics = WorkloadManagementPerNodeMetrics;
+    /**
+     * Metrics for dimension set: QueryPriority {ClusterIdentifier, QueryPriority}
+     *
+     * @stability external
+     */
+    class QueryPriorityMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                QueryPriority: props.queryPriority
+            };
+        }
+        /**
+         * Average of the WLMQueueWaitTime metric
+         *
+         * @default - Average over 5 minutes
+         */
+        wlmQueueWaitTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "WLMQueueWaitTime",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.QueryPriorityMetrics = QueryPriorityMetrics;
+    /**
+     * Metrics for dimension set: StagePerNode {ClusterIdentifier, stage, NodeID}
+     *
+     * @stability external
+     */
+    class StagePerNodeMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                stage: props.stage,
+                NodeID: props.nodeId
+            };
+        }
+        /**
+         * Average of the QueryRuntimeBreakdown metric
+         *
+         * @default - Average over 5 minutes
+         */
+        queryRuntimeBreakdown(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "QueryRuntimeBreakdown",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.StagePerNodeMetrics = StagePerNodeMetrics;
+    /**
+     * Metrics for dimension set: Stage {ClusterIdentifier, stage}
+     *
+     * @stability external
+     */
+    class StageMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                stage: props.stage
+            };
+        }
+        /**
+         * Average of the QueryRuntimeBreakdown metric
+         *
+         * @default - Average over 5 minutes
+         */
+        queryRuntimeBreakdown(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "QueryRuntimeBreakdown",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.StageMetrics = StageMetrics;
+    /**
+     * Metrics for dimension set: Latency {ClusterIdentifier, latency}
+     *
+     * @stability external
+     */
+    class LatencyMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                latency: props.latency
+            };
+        }
+        /**
+         * Average of the QueriesCompletedPerSecond metric
+         *
+         * @default - Average over 5 minutes
+         */
+        queriesCompletedPerSecond(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "QueriesCompletedPerSecond",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the QueryDuration metric
+         *
+         * @default - Average over 5 minutes
+         */
+        queryDuration(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "QueryDuration",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.LatencyMetrics = LatencyMetrics;
+    /**
+     * Metrics for dimension set: LatencyPerNode {ClusterIdentifier, latency, NodeID}
+     *
+     * @stability external
+     */
+    class LatencyPerNodeMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ClusterIdentifier: props.clusterIdentifier,
+                latency: props.latency,
+                NodeID: props.nodeId
+            };
+        }
+        /**
+         * Average of the QueriesCompletedPerSecond metric
+         *
+         * @default - Average over 5 minutes
+         */
+        queriesCompletedPerSecond(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "QueriesCompletedPerSecond",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the QueryDuration metric
+         *
+         * @default - Average over 5 minutes
+         */
+        queryDuration(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/Redshift",
+                metricName: "QueryDuration",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    RedshiftMetrics.LatencyPerNodeMetrics = LatencyPerNodeMetrics;
+})(RedshiftMetrics || (exports.RedshiftMetrics = RedshiftMetrics = {}));