feat!: update more MetricFactory classes to extend base (#541)

Eugene Cheung · web-flow · commit 8ee401080df5 · 2024-07-03T09:50:11.000-04:00
This is a continuation of #534, but it includes breaking changes to some existing metric factories' constructor API contracts. Also includes some minor private method renaming for consistency and a basic facade test, pulled out from #533. --- _By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license_
diff --git a/.projen/tasks.json b/.projen/tasks.json
diff --git a/.projenrc.ts b/.projenrc.ts
@@ -18,7 +18,7 @@ const project = new awscdk.AwsCdkConstructLibrary({
   keywords: ["cloudwatch", "monitoring"],
 
   defaultReleaseBranch: "main",
-  majorVersion: 7,
+  majorVersion: 8,
   stability: "experimental",
 
   cdkVersion: CDK_VERSION,
diff --git a/API.md b/API.md
diff --git a/lib/monitoring/aws-ec2/EC2MetricFactory.ts b/lib/monitoring/aws-ec2/EC2MetricFactory.ts
@@ -157,7 +157,7 @@ export class EC2MetricFactory extends BaseMetricFactory<EC2MetricFactoryProps> {
    * CloudWatch when the instance is not allocated a full processor core.
    */
   metricAverageCpuUtilisationPercent() {
-    return this.createMetrics("CPUUtilization", MetricStatistic.AVERAGE);
+    return this.metric("CPUUtilization", MetricStatistic.AVERAGE);
   }
 
   /**
@@ -197,15 +197,15 @@ export class EC2MetricFactory extends BaseMetricFactory<EC2MetricFactoryProps> {
    * This metric identifies the volume of incoming network traffic to a single instance.
    */
   metricAverageNetworkInRateBytes() {
-    return this.createMetrics("NetworkIn", MetricStatistic.AVERAGE);
+    return this.metric("NetworkIn", MetricStatistic.AVERAGE);
   }
 
   /**
    * The number of bytes sent out on all network interfaces by the instance.
    * This metric identifies the volume of outgoing network traffic from a single instance.
    */
   metricAverageNetworkOutRateBytes() {
-    return this.createMetrics("NetworkOut", MetricStatistic.AVERAGE);
+    return this.metric("NetworkOut", MetricStatistic.AVERAGE);
   }
 
   private createDiskMetrics(metricName: string, statistic: MetricStatistic) {
@@ -235,7 +235,7 @@ export class EC2MetricFactory extends BaseMetricFactory<EC2MetricFactoryProps> {
     });
   }
 
-  private createMetrics(metricName: string, statistic: MetricStatistic) {
+  private metric(metricName: string, statistic: MetricStatistic) {
     return this.strategy.createMetrics(
       this.metricFactory,
       metricName,
diff --git a/lib/monitoring/aws-kinesisanalytics/KinesisDataAnalyticsMetricFactory.ts b/lib/monitoring/aws-kinesisanalytics/KinesisDataAnalyticsMetricFactory.ts
@@ -39,92 +39,92 @@ export class KinesisDataAnalyticsMetricFactory extends BaseMetricFactory<Kinesis
   }
 
   metricKPUsCount() {
-    return this.generateMetric({
+    return this.metric({
       name: "KPUs",
       description: "Kinesis Processing Units",
     });
   }
 
   metricDowntimeMs() {
-    return this.generateMetric({
+    return this.metric({
       name: "downtime",
       description: "Downtime",
     });
   }
 
   metricUptimeMs() {
-    return this.generateMetric({
+    return this.metric({
       name: "uptime",
       description: "Uptime",
     });
   }
 
   metricFullRestartsCount() {
-    return this.generateMetric({
+    return this.metric({
       name: "fullRestarts",
       description: "Restarts",
     });
   }
 
   metricNumberOfFailedCheckpointsCount() {
-    return this.generateMetric({
+    return this.metric({
       name: "numberOfFailedCheckpoints",
       description: "Failed Checkpoints",
       metricStatistic: MetricStatistic.SUM,
     });
   }
 
   metricLastCheckpointDurationMs() {
-    return this.generateMetric({
+    return this.metric({
       name: "lastCheckpointDuration",
       description: "Last Checkpoint Duration",
     });
   }
 
   metricLastCheckpointSizeBytes() {
-    return this.generateMetric({
+    return this.metric({
       name: "lastCheckpointSize",
       description: "Last Checkpoint Size",
       metricStatistic: MetricStatistic.SUM,
     });
   }
 
   metricCpuUtilizationPercent() {
-    return this.generateMetric({
+    return this.metric({
       name: "cpuUtilization",
       description: "CPU Utilization",
     });
   }
 
   metricHeapMemoryUtilizationPercent() {
-    return this.generateMetric({
+    return this.metric({
       name: "heapMemoryUtilization",
       description: "Heap Memory Utilization",
     });
   }
 
   metricOldGenerationGCTimeMs() {
-    return this.generateMetric({
+    return this.metric({
       name: "oldGenerationGCTime",
       description: "GC Time",
     });
   }
 
   metricOldGenerationGCCount() {
-    return this.generateMetric({
+    return this.metric({
       name: "oldGenerationGCCount",
       metricStatistic: MetricStatistic.N,
       description: "GC Count",
     });
   }
 
-  private generateMetric(metricsSpec: MetricsSpec) {
+  private metric(metricsSpec: MetricsSpec) {
     return this.metricFactory.createMetric(
       metricsSpec.name,
-      metricsSpec.metricStatistic || MetricStatistic.AVERAGE,
+      metricsSpec.metricStatistic ?? MetricStatistic.AVERAGE,
       metricsSpec.description,
       this.dimensionsMap,
-      undefined, // the hex color code of the metric on a graph
+      undefined,
       "AWS/KinesisAnalytics",
     );
   }
diff --git a/lib/monitoring/aws-lambda/LambdaFunctionEnhancedMetricFactory.ts b/lib/monitoring/aws-lambda/LambdaFunctionEnhancedMetricFactory.ts
@@ -1,16 +1,29 @@
 import { IFunction } from "aws-cdk-lib/aws-lambda";
 
-import { MetricFactory, MetricStatistic } from "../../common";
+import {
+  BaseMetricFactory,
+  BaseMetricFactoryProps,
+  MetricFactory,
+  MetricStatistic,
+} from "../../common";
 
 const LambdaInsightsNamespace = "LambdaInsights";
 
-export class LambdaFunctionEnhancedMetricFactory {
-  protected readonly metricFactory: MetricFactory;
+export interface LambdaFunctionEnhancedMetricFactoryProps
+  extends BaseMetricFactoryProps {
+  readonly lambdaFunction: IFunction;
+}
+
+export class LambdaFunctionEnhancedMetricFactory extends BaseMetricFactory<LambdaFunctionEnhancedMetricFactoryProps> {
   protected readonly lambdaFunction: IFunction;
 
-  constructor(metricFactory: MetricFactory, lambdaFunction: IFunction) {
-    this.metricFactory = metricFactory;
-    this.lambdaFunction = lambdaFunction;
+  constructor(
+    metricFactory: MetricFactory,
+    props: LambdaFunctionEnhancedMetricFactoryProps,
+  ) {
+    super(metricFactory, props);
+
+    this.lambdaFunction = props.lambdaFunction;
   }
 
   enhancedMetricMaxCpuTotalTime() {
diff --git a/lib/monitoring/aws-lambda/LambdaFunctionMetricFactory.ts b/lib/monitoring/aws-lambda/LambdaFunctionMetricFactory.ts
@@ -166,9 +166,8 @@ export class LambdaFunctionMetricFactory extends BaseMetricFactory<LambdaFunctio
   }
 
   metricProvisionedConcurrencySpilloverRate() {
-    const metric = this.metricProvisionedConcurrencySpilloverInvocations();
     return this.metricFactory.toRate(
-      metric,
+      this.metricProvisionedConcurrencySpilloverInvocations(),
       this.rateComputationMethod,
       false,
       "pcsi",
diff --git a/lib/monitoring/aws-lambda/LambdaFunctionMonitoring.ts b/lib/monitoring/aws-lambda/LambdaFunctionMonitoring.ts
@@ -234,7 +234,7 @@ export class LambdaFunctionMonitoring extends Monitoring {
     if (props.lambdaInsightsEnabled) {
       this.enhancedMetricFactory = new LambdaFunctionEnhancedMetricFactory(
         scope.createMetricFactory(),
-        props.lambdaFunction,
+        props,
       );
       this.enhancedMonitoringMaxCpuTotalTimeMetric =
         this.enhancedMetricFactory.enhancedMetricMaxCpuTotalTime();
diff --git a/lib/monitoring/aws-secretsmanager/SecretsManagerMetricFactory.ts b/lib/monitoring/aws-secretsmanager/SecretsManagerMetricFactory.ts
@@ -1,5 +1,10 @@
 import { Duration } from "aws-cdk-lib";
-import { MetricFactory, MetricStatistic } from "../../common";
+import {
+  BaseMetricFactory,
+  BaseMetricFactoryProps,
+  MetricFactory,
+  MetricStatistic,
+} from "../../common";
 
 const CLASS = "None";
 const DEFAULT_METRIC_PERIOD = Duration.hours(1);
@@ -9,11 +14,14 @@ const RESOURCE = "SecretCount";
 const SERVICE = "Secrets Manager";
 const TYPE = "Resource";
 
-export class SecretsManagerMetricFactory {
-  protected readonly metricFactory: MetricFactory;
+export type SecretsManagerMetricFactoryProps = BaseMetricFactoryProps;
 
-  constructor(metricFactory: MetricFactory) {
-    this.metricFactory = metricFactory;
+export class SecretsManagerMetricFactory extends BaseMetricFactory<SecretsManagerMetricFactoryProps> {
+  constructor(
+    metricFactory: MetricFactory,
+    props: SecretsManagerMetricFactoryProps,
+  ) {
+    super(metricFactory, props);
   }
 
   metricSecretCount() {
diff --git a/lib/monitoring/aws-secretsmanager/SecretsManagerMonitoring.ts b/lib/monitoring/aws-secretsmanager/SecretsManagerMonitoring.ts
@@ -64,6 +64,7 @@ export class SecretsManagerMonitoring extends Monitoring {
 
     const metricFactory = new SecretsManagerMetricFactory(
       scope.createMetricFactory(),
+      props,
     );
     this.secretsCountMetric = metricFactory.metricSecretCount();
 
diff --git a/lib/monitoring/fluentbit/FluentBitMetricFactory.ts b/lib/monitoring/fluentbit/FluentBitMetricFactory.ts
@@ -6,24 +6,29 @@ import {
   FluentBitOutputMetricTag,
   FluentBitStorageMetricTag,
 } from "./FluentBitConstants";
-import { MetricFactory, MetricStatistic, MonitoringScope } from "../../common";
+import {
+  BaseMetricFactory,
+  BaseMetricFactoryProps,
+  MetricStatistic,
+  MonitoringScope,
+} from "../../common";
 
-export interface FluentBitMetricFactoryProps {
+export interface FluentBitMetricFactoryProps extends BaseMetricFactoryProps {
   /**
    * Namespace that metrics will be emitted to.
    * @default metric factory default
    */
   readonly namespace?: string;
 }
 
-export class FluentBitMetricFactory {
-  protected readonly metricFactory: MetricFactory;
+export class FluentBitMetricFactory extends BaseMetricFactory<FluentBitMetricFactoryProps> {
   protected readonly namespace: string;
   protected readonly scope: MonitoringScope;
 
   constructor(scope: MonitoringScope, props: FluentBitMetricFactoryProps) {
+    super(scope.createMetricFactory(), props);
+
     this.scope = scope;
-    this.metricFactory = scope.createMetricFactory();
     this.namespace =
       props.namespace ??
       this.metricFactory.getNamespaceWithFallback(props.namespace);
@@ -78,10 +83,9 @@ export class FluentBitMetricFactory {
           metricValue: `${valueString}`,
         },
       );
-      const metric = metricFilter.metric({
+      return metricFilter.metric({
         statistic: MetricStatistic.MAX,
       });
-      return metric;
     });
   }
 
diff --git a/test/facade/MonitoringFacade.test.ts b/test/facade/MonitoringFacade.test.ts
diff --git a/test/facade/__snapshots__/MonitoringFacade.test.ts.snap b/test/facade/__snapshots__/MonitoringFacade.test.ts.snap
