feat(elbv2): Accept imported load balancer and target groups (#329)

After CDK 2.65.0, it is  now possible to obtain metrics through the interfaces. This opens up the possibility of creating dashboards for the imported versions of these resources.

PS: The tests have such large diffs because of the extra indentation.  The code is very similar, I just added the extra factory (`lbResourcesFactory`), but git is confused here.

---

_By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license_

Author: edisongustavo

.projen/deps.json

@@ -1,7 +1,7 @@
 const { awscdk, javascript, DependencyType } = require("projen");
 const { workflows } = require("projen/lib/github");
 
-const CDK_VERSION = "2.60.0";
+const CDK_VERSION = "2.65.0";
 
 const project = new awscdk.AwsCdkConstructLibrary({
   name: "cdk-monitoring-constructs",
@@ -11,7 +11,7 @@ const project = new awscdk.AwsCdkConstructLibrary({
   keywords: ["cloudwatch", "monitoring"],
 
   defaultReleaseBranch: "main",
-  majorVersion: 2,
+  majorVersion: 3,
   stability: "experimental",
 
   cdkVersion: CDK_VERSION,

.projen/tasks.json

@@ -26,13 +26,13 @@ In your `package.json`:
 ```json
 {
   "dependencies": {
-    "cdk-monitoring-constructs": "^2.0.0",
+    "cdk-monitoring-constructs": "^3.0.0",
 
     // peer dependencies of cdk-monitoring-constructs
-    "@aws-cdk/aws-apigatewayv2-alpha": "^2.60.0-alpha.0",
-    "@aws-cdk/aws-redshift-alpha": "^2.60.0-alpha.0",
-    "@aws-cdk/aws-synthetics-alpha": "^2.60.0-alpha.0",
-    "aws-cdk-lib": "^2.60.0",
+    "@aws-cdk/aws-apigatewayv2-alpha": "^2.65.0-alpha.0",
+    "@aws-cdk/aws-redshift-alpha": "^2.65.0-alpha.0",
+    "@aws-cdk/aws-synthetics-alpha": "^2.65.0-alpha.0",
+    "aws-cdk-lib": "^2.65.0",
     "constructs": "^10.0.5"
 
     // ...your other dependencies...

.projenrc.js

@@ -10,10 +10,10 @@ import {
   NetworkLoadBalancedEc2Service,
 } from "aws-cdk-lib/aws-ecs-patterns";
 import {
-  ApplicationLoadBalancer,
-  ApplicationTargetGroup,
-  NetworkLoadBalancer,
-  NetworkTargetGroup,
+  IApplicationLoadBalancer,
+  IApplicationTargetGroup,
+  INetworkLoadBalancer,
+  INetworkTargetGroup,
 } from "aws-cdk-lib/aws-elasticloadbalancingv2";
 
 import { BaseServiceMetricFactory } from "./BaseServiceMetricFactory";
@@ -135,8 +135,8 @@ export interface Ec2ApplicationLoadBalancerMonitoringProps
 export interface CustomEc2ServiceMonitoringProps
   extends BaseLoadBalancedEc2ServiceMonitoringProps {
   readonly ec2Service: Ec2Service;
-  readonly loadBalancer?: ApplicationLoadBalancer | NetworkLoadBalancer;
-  readonly targetGroup?: ApplicationTargetGroup | NetworkTargetGroup;
+  readonly loadBalancer?: IApplicationLoadBalancer | INetworkLoadBalancer;
+  readonly targetGroup?: IApplicationTargetGroup | INetworkTargetGroup;
 }
 
 export class Ec2ServiceMonitoring extends Monitoring {
@@ -186,8 +186,8 @@ export class Ec2ServiceMonitoring extends Monitoring {
     if (this.hasLoadBalancer) {
       this.loadBalancerMetricFactory = createLoadBalancerMetricFactory(
         this.metricFactory,
-        props.loadBalancer,
-        props.targetGroup
+        props.loadBalancer!,
+        props.targetGroup!
       );
       this.healthyTaskCountMetric =
         this.loadBalancerMetricFactory.metricHealthyTaskCount();

API.md

@@ -10,10 +10,10 @@ import {
   NetworkLoadBalancedFargateService,
 } from "aws-cdk-lib/aws-ecs-patterns";
 import {
-  ApplicationLoadBalancer,
-  ApplicationTargetGroup,
-  NetworkLoadBalancer,
-  NetworkTargetGroup,
+  IApplicationLoadBalancer,
+  IApplicationTargetGroup,
+  INetworkLoadBalancer,
+  INetworkTargetGroup,
 } from "aws-cdk-lib/aws-elasticloadbalancingv2";
 
 import { BaseServiceMetricFactory } from "./BaseServiceMetricFactory";
@@ -135,8 +135,8 @@ export interface FargateApplicationLoadBalancerMonitoringProps
 export interface CustomFargateServiceMonitoringProps
   extends BaseLoadBalancedFargateServiceMonitoringProps {
   readonly fargateService: FargateService;
-  readonly loadBalancer?: ApplicationLoadBalancer | NetworkLoadBalancer;
-  readonly targetGroup?: ApplicationTargetGroup | NetworkTargetGroup;
+  readonly loadBalancer?: IApplicationLoadBalancer | INetworkLoadBalancer;
+  readonly targetGroup?: IApplicationTargetGroup | INetworkTargetGroup;
 }
 
 export class FargateServiceMonitoring extends Monitoring {
@@ -189,8 +189,8 @@ export class FargateServiceMonitoring extends Monitoring {
     if (this.hasLoadBalancer) {
       this.loadBalancerMetricFactory = createLoadBalancerMetricFactory(
         this.metricFactory,
-        props.loadBalancer,
-        props.targetGroup
+        props.loadBalancer!,
+        props.targetGroup!
       );
       this.healthyTaskCountMetric =
         this.loadBalancerMetricFactory.metricHealthyTaskCount();

README.md

@@ -1,6 +1,6 @@
 import {
-  ApplicationLoadBalancer,
-  ApplicationTargetGroup,
+  IApplicationLoadBalancer,
+  IApplicationTargetGroup,
 } from "aws-cdk-lib/aws-elasticloadbalancingv2";
 
 import { ILoadBalancerMetricFactory } from "./LoadBalancerMetricFactory";
@@ -15,8 +15,8 @@ import {
  * Props to create ApplicationLoadBalancerMetricFactory.
  */
 export interface ApplicationLoadBalancerMetricFactoryProps {
-  readonly applicationLoadBalancer: ApplicationLoadBalancer;
-  readonly applicationTargetGroup: ApplicationTargetGroup;
+  readonly applicationLoadBalancer: IApplicationLoadBalancer;
+  readonly applicationTargetGroup: IApplicationTargetGroup;
 }
 
 /**
@@ -26,8 +26,8 @@ export class ApplicationLoadBalancerMetricFactory
   implements ILoadBalancerMetricFactory
 {
   protected readonly metricFactory: MetricFactory;
-  protected readonly applicationLoadBalancer: ApplicationLoadBalancer;
-  protected readonly applicationTargetGroup: ApplicationTargetGroup;
+  protected readonly applicationLoadBalancer: IApplicationLoadBalancer;
+  protected readonly applicationTargetGroup: IApplicationTargetGroup;
 
   constructor(
     metricFactory: MetricFactory,
@@ -40,7 +40,7 @@ export class ApplicationLoadBalancerMetricFactory
 
   metricHealthyTaskCount() {
     return this.metricFactory.adaptMetric(
-      this.applicationTargetGroup.metricHealthyHostCount({
+      this.applicationTargetGroup.metrics.healthyHostCount({
         label: "Healthy Tasks",
         color: HealthyMetricColor,
         statistic: MetricStatistic.MIN,
@@ -50,7 +50,7 @@ export class ApplicationLoadBalancerMetricFactory
 
   metricUnhealthyTaskCount() {
     return this.metricFactory.adaptMetric(
-      this.applicationTargetGroup.metricUnhealthyHostCount({
+      this.applicationTargetGroup.metrics.unhealthyHostCount({
         label: "Unhealthy Tasks",
         color: UnhealthyMetricColor,
         statistic: MetricStatistic.MAX,
@@ -70,23 +70,23 @@ export class ApplicationLoadBalancerMetricFactory
 
   metricActiveConnectionCount() {
     return this.metricFactory.adaptMetric(
-      this.applicationLoadBalancer.metricActiveConnectionCount({
+      this.applicationLoadBalancer.metrics.activeConnectionCount({
         label: "Active",
       })
     );
   }
 
   metricNewConnectionCount() {
     return this.metricFactory.adaptMetric(
-      this.applicationLoadBalancer.metricNewConnectionCount({
+      this.applicationLoadBalancer.metrics.newConnectionCount({
         label: "New",
       })
     );
   }
 
   metricProcessedBytesMin() {
     return this.metricFactory.adaptMetric(
-      this.applicationLoadBalancer.metricProcessedBytes({
+      this.applicationLoadBalancer.metrics.processedBytes({
         statistic: MetricStatistic.MIN,
         label: "Processed Bytes (min)",
       })

lib/monitoring/aws-ecs-patterns/Ec2ServiceMonitoring.ts

@@ -1,14 +1,42 @@
 import {
-  ApplicationLoadBalancer,
-  ApplicationTargetGroup,
-  NetworkLoadBalancer,
-  NetworkTargetGroup,
+  IApplicationLoadBalancer,
+  IApplicationTargetGroup,
+  INetworkLoadBalancer,
+  INetworkTargetGroup,
 } from "aws-cdk-lib/aws-elasticloadbalancingv2";
 
 import { ApplicationLoadBalancerMetricFactory } from "./ApplicationLoadBalancerMetricFactory";
 import { NetworkLoadBalancerMetricFactory } from "./NetworkLoadBalancerMetricFactory";
 import { MetricFactory, MetricWithAlarmSupport } from "../../common";
 
+// It's not possible to use instanceOf with typescript interfaces, so we have to use type guards to differentiate
+// between the interfaces. As another problem, the LoadBalancer/TargetGroup for both Network and Application types
+// don't have distinguished fields that could be used to differentiate between both types, so we resort to using
+// the name of the class below.
+//
+// Ideally the 2 interfaces would provide a specific field to distinguish both types.
+function isApplicationLoadBalancer(
+  loadBalancer: INetworkLoadBalancer | IApplicationLoadBalancer
+): loadBalancer is IApplicationLoadBalancer {
+  return loadBalancer.constructor.name.indexOf("Application") != -1;
+}
+function isNetworkLoadBalancer(
+  loadBalancer: INetworkLoadBalancer | IApplicationLoadBalancer
+): loadBalancer is INetworkLoadBalancer {
+  return loadBalancer.constructor.name.indexOf("Network") != -1;
+}
+
+function isApplicationTargetGroup(
+  targetGroup: INetworkTargetGroup | IApplicationTargetGroup
+): targetGroup is IApplicationTargetGroup {
+  return targetGroup.constructor.name.indexOf("Application") != -1;
+}
+function isNetworkTargetGroup(
+  targetGroup: INetworkTargetGroup | IApplicationTargetGroup
+): targetGroup is INetworkTargetGroup {
+  return targetGroup.constructor.name.indexOf("Network") != -1;
+}
+
 /**
  * Factory method to create appropriate metric factory based on the load balancer and target group type.
  * @param metricFactory metric factory
@@ -17,28 +45,28 @@ import { MetricFactory, MetricWithAlarmSupport } from "../../common";
  */
 export function createLoadBalancerMetricFactory(
   metricFactory: MetricFactory,
-  loadBalancer: any,
-  targetGroup: any
+  loadBalancer: INetworkLoadBalancer | IApplicationLoadBalancer,
+  targetGroup: INetworkTargetGroup | IApplicationTargetGroup
 ): ILoadBalancerMetricFactory {
   if (
-    loadBalancer instanceof NetworkLoadBalancer &&
-    targetGroup instanceof NetworkTargetGroup
+    isNetworkLoadBalancer(loadBalancer) &&
+    isNetworkTargetGroup(targetGroup)
   ) {
     return new NetworkLoadBalancerMetricFactory(metricFactory, {
       networkLoadBalancer: loadBalancer,
       networkTargetGroup: targetGroup,
     });
   } else if (
-    loadBalancer instanceof ApplicationLoadBalancer &&
-    targetGroup instanceof ApplicationTargetGroup
+    isApplicationLoadBalancer(loadBalancer) &&
+    isApplicationTargetGroup(targetGroup)
   ) {
     return new ApplicationLoadBalancerMetricFactory(metricFactory, {
       applicationLoadBalancer: loadBalancer,
       applicationTargetGroup: targetGroup,
     });
   } else {
     throw new Error(
-      "Invalid type of load balancer or target group (only ALB and ELB is supported)."
+      "Invalid type of load balancer or target group (only ALB and NLB are supported)."
     );
   }
 }