@gradientedge/cdk-utils 7.22.0 → 8.1.0

package/src/lib/manager/aws/cloudwatch-manager.ts

@@ -12,6 +12,7 @@ import * as utils from '../../utils'
 enum CloudWatchWidgetType {
   Text = 'Text',
   SingleValue = 'SingleValue',
+  Gauge = 'Gauge',
   Graph = 'Graph',
   AlarmStatus = 'AlarmStatus',
   LogQuery = 'LogQuery',
@@ -45,7 +46,7 @@ export class CloudWatchManager {
    * @param {types.AlarmProps} props
    */
   public createAlarmForExpression(id: string, scope: common.CommonConstruct, props: types.AlarmProps) {
-    if (!props) throw `Alarm props undefined`
+    if (!props) throw `Alarm props undefined for ${id}`
 
     if (!props.expression) throw `Could not find expression for Alarm props for id:${id}`
     if (!props.metricProps) throw `Could not find metricProps for Alarm props for id:${id}`
@@ -89,7 +90,7 @@ export class CloudWatchManager {
     props: types.AlarmProps,
     metric: watch.Metric
   ) {
-    if (!props) throw `Alarm props undefined`
+    if (!props) throw `Alarm props undefined for ${id}`
 
     const alarm = metric.createAlarm(scope, `${id}`, {
       alarmName: props.alarmName,
@@ -120,7 +121,7 @@ export class CloudWatchManager {
     props: types.DashboardProps,
     widgets?: watch.IWidget[][]
   ) {
-    if (!props) throw `Dashboard props undefined`
+    if (!props) throw `Dashboard props undefined for ${id}`
 
     const dashboard = new watch.Dashboard(scope, `${id}`, {
       dashboardName: props.dashboardName,
@@ -156,7 +157,7 @@ export class CloudWatchManager {
    * @param props
    */
   public createWidget(id: string, scope: common.CommonConstruct, props: any) {
-    if (!props) throw `Widget props undefined`
+    if (!props) throw `Widget props undefined for ${id}`
 
     const metrics = this.determineMetrics(scope, props.metricProps)
     let alarms,
@@ -166,6 +167,8 @@ export class CloudWatchManager {
         return this.createTextWidget(id, scope, props)
       case CloudWatchWidgetType.SingleValue:
         return this.createSingleValueWidget(id, scope, props, metrics)
+      case CloudWatchWidgetType.Gauge:
+        return this.createGuageWidget(id, scope, props, metrics)
       case CloudWatchWidgetType.Graph:
         return this.createGraphWidget(id, scope, props, metrics)
       case CloudWatchWidgetType.AlarmStatus:
@@ -175,10 +178,197 @@ export class CloudWatchManager {
         logGroupNames = props.logGroupNames.map((name: string) => `${name}-${scope.props.stage}`)
         return this.createLogQueryWidget(id, scope, props, logGroupNames)
       default:
-        throw 'Unsupported widget type'
+        throw `Unsupported widget type ${props.type}`
     }
   }
 
+  /**
+   * @summary Method to create a cloudfront distribution widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} distributionId the cloudfront distribution id
+   */
+  public createCloudfrontDistributionWidget(
+    id: string,
+    scope: common.CommonConstruct,
+    props: any,
+    distributionId: string
+  ) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({ ...metricProp, ...{ distributionId: distributionId } })),
+      },
+    })
+  }
+
+  /**
+   * @summary Method to create a step function widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} stateMachineArn the step function arn
+   */
+  public createStateWidget(id: string, scope: common.CommonConstruct, props: any, stateMachineArn: string) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({ ...metricProp, ...{ stateMachineArn: stateMachineArn } })),
+      },
+    })
+  }
+
+  /**
+   * @summary Method to create an event widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} eventBusName the event bus name
+   * @param {string} ruleName the event rule name
+   */
+  public createEventWidget(
+    id: string,
+    scope: common.CommonConstruct,
+    props: any,
+    eventBusName: string,
+    ruleName: string
+  ) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({
+          ...metricProp,
+          ...{ eventBusName: eventBusName, ruleName: ruleName },
+        })),
+      },
+    })
+  }
+
+  /**
+   * @summary Method to create an api gateway widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} apiName the api name
+   */
+  public createApiGatewayWidget(id: string, scope: common.CommonConstruct, props: any, apiName: string) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({ ...metricProp, ...{ apiName: apiName } })),
+      },
+    })
+  }
+
+  /**
+   * @summary Method to create a lambda function widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} functionName the lambda function name
+   */
+  public createLambdaWidget(id: string, scope: common.CommonConstruct, props: any, functionName: string) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({ ...metricProp, ...{ functionName: functionName } })),
+      },
+    })
+  }
+
+  /**
+   * @summary Method to create an ecs cluster widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} clusterName the ecs cluster name
+   */
+  public createEcsClusterWidget(id: string, scope: common.CommonConstruct, props: any, clusterName: string) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({ ...metricProp, ...{ clusterName: clusterName } })),
+      },
+    })
+  }
+
+  /**
+   * @summary Method to create an ecs service widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} clusterName the ecs cluster name
+   * @param {string} serviceName the ecs service name
+   */
+  public createEcsServiceWidget(
+    id: string,
+    scope: common.CommonConstruct,
+    props: any,
+    clusterName: string,
+    serviceName: string
+  ) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({
+          ...metricProp,
+          ...{ clusterName: clusterName, serviceName: serviceName },
+        })),
+      },
+    })
+  }
+
+  /**
+   * @summary Method to create an elb widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} loadBalancer the loadbalancer reference
+   */
+  public createElbWidget(id: string, scope: common.CommonConstruct, props: any, loadBalancer: string) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({ ...metricProp, ...{ loadBalancer: loadBalancer } })),
+      },
+    })
+  }
+
+  /**
+   * @summary Method to create an elasticache widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.TextWidgetProps} props
+   * @param {string} cacheClusterId the elasticache cluster id
+   */
+  public createCacheWidget(id: string, scope: common.CommonConstruct, props: any, cacheClusterId: string) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const metricProps: any[] = props.metricProps
+    return this.createWidget(id, scope, {
+      ...props,
+      ...{
+        metricProps: metricProps.map(metricProp => ({ ...metricProp, ...{ cacheClusterId: cacheClusterId } })),
+      },
+    })
+  }
+
   /**
    * @summary Method to create a cloudwatch text widget
    * @param {string} id scoped id of the resource
@@ -186,6 +376,7 @@ export class CloudWatchManager {
    * @param {types.TextWidgetProps} props
    */
   public createTextWidget(id: string, scope: common.CommonConstruct, props: types.TextWidgetProps) {
+    if (!props) throw `Widget props undefined for ${id}`
     const widget = new watch.TextWidget({
       markdown: props.markdown,
       width: props.width,
@@ -210,10 +401,43 @@ export class CloudWatchManager {
     props: types.NumericWidgetProps,
     metrics: IMetric[]
   ) {
+    if (!props) throw `Widget props undefined for ${id}`
     const widget = new watch.SingleValueWidget({
+      region: props.region ?? scope.props.region,
       metrics: metrics,
       setPeriodToTimeRange: props.setPeriodToTimeRange,
       fullPrecision: props.fullPrecision,
+      sparkline: props.sparkline,
+      title: props.title,
+      width: props.width,
+      height: props.height,
+    })
+
+    if (props.positionX && props.positionY) widget.position(props.positionX, props.positionY)
+
+    return widget
+  }
+
+  /**
+   * @summary Method to create a cloudwatch guage widget
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.GuageWidgetProps} props
+   * @param metrics
+   */
+  public createGuageWidget(
+    id: string,
+    scope: common.CommonConstruct,
+    props: types.GuageWidgetProps,
+    metrics: IMetric[]
+  ) {
+    if (!props) throw `Widget props undefined for ${id}`
+    const widget = new watch.GaugeWidget({
+      region: props.region ?? scope.props.region,
+      metrics: metrics,
+      leftYAxis: props.leftYAxis,
+      statistic: props.statistic,
+      setPeriodToTimeRange: props.setPeriodToTimeRange,
       title: props.title,
       width: props.width,
       height: props.height,
@@ -239,7 +463,9 @@ export class CloudWatchManager {
     leftYMetrics?: IMetric[],
     rightYMetrics?: IMetric[]
   ) {
+    if (!props) throw `Widget props undefined for ${id}`
     const widget = new watch.GraphWidget({
+      region: props.region ?? scope.props.region,
       left: leftYMetrics,
       right: rightYMetrics,
       leftAnnotations: props.leftAnnotations,
@@ -273,6 +499,7 @@ export class CloudWatchManager {
     props: types.AlarmStatusWidgetProps,
     alarms: watch.IAlarm[]
   ) {
+    if (!props) throw `Widget props undefined for ${id}`
     const widget = new watch.AlarmStatusWidget({
       alarms: alarms,
       title: props.title,
@@ -298,7 +525,9 @@ export class CloudWatchManager {
     props: types.LogQueryWidgetProps,
     logGroupNames: string[]
   ) {
+    if (!props) throw `Widget props undefined for ${id}`
     const widget = new watch.LogQueryWidget({
+      region: props.region ?? scope.props.region,
       logGroupNames: logGroupNames,
       queryString: props.queryString,
       queryLines: props.queryLines,
@@ -327,7 +556,65 @@ export class CloudWatchManager {
           metricDimensions = {
             ...metricProp.dimensionsMap,
             ...{
-              FunctionName: `${metricProp.functionName}-${scope.props.stage}`,
+              FunctionName: `${metricProp.functionName}`,
+            },
+          }
+        }
+        if (metricProp.serviceName && metricProp.clusterName) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              ServiceName: `${metricProp.serviceName}`,
+              ClusterName: `${metricProp.clusterName}`,
+            },
+          }
+        }
+        if (!metricProp.serviceName && metricProp.clusterName) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              ClusterName: `${metricProp.clusterName}`,
+            },
+          }
+        }
+        if (metricProp.serviceName && !metricProp.clusterName) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              ServiceName: `${metricProp.serviceName}`,
+            },
+          }
+        }
+        if (metricProp.loadBalancer) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              LoadBalancer: `${metricProp.loadBalancer}`,
+            },
+          }
+        }
+        if (metricProp.distributionId) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              Region: `Global`,
+              DistributionId: `${metricProp.distributionId}`,
+            },
+          }
+        }
+        if (metricProp.apiName) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              ApiName: `${metricProp.apiName}`,
+            },
+          }
+        }
+        if (metricProp.cacheClusterId) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              CacheClusterId: `${metricProp.cacheClusterId}`,
             },
           }
         }
@@ -335,7 +622,25 @@ export class CloudWatchManager {
           metricDimensions = {
             ...metricProp.dimensionsMap,
             ...{
-              DBClusterIdentifier: `${metricProp.dbClusterIdentifier}-${scope.props.stage}`,
+              DBClusterIdentifier: `${metricProp.dbClusterIdentifier}`,
+            },
+          }
+        }
+        if (metricProp.stateMachineArn) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              StateMachineArn: `${metricProp.stateMachineArn}`,
+            },
+          }
+        }
+
+        if (metricProp.eventBusName && metricProp.ruleName) {
+          metricDimensions = {
+            ...metricProp.dimensionsMap,
+            ...{
+              EventBusName: `${metricProp.eventBusName}`,
+              RuleName: `${metricProp.ruleName}`,
             },
           }
         }

package/src/lib/manager/aws/dynamodb-manager.ts

@@ -31,7 +31,7 @@ export class DynamodbManager {
    * @param {types.TableProps} props table props
    */
   public createTable(id: string, scope: common.CommonConstruct, props: types.TableProps) {
-    if (!props) throw `Table props undefined`
+    if (!props) throw `Table props undefined for ${id}`
 
     const table = new dynamodb.Table(scope, `${id}`, {
       tableName: `${props.tableName}-${scope.props.stage}`,

package/src/lib/manager/aws/ecs-manager.ts

@@ -37,7 +37,7 @@ export class EcsManager {
    * @param {ec2.IVpc} vpc
    */
   public createEcsCluster(id: string, scope: common.CommonConstruct, props: types.EcsClusterProps, vpc: ec2.IVpc) {
-    if (!props) throw `Ecs Cluster props undefined`
+    if (!props) throw `Ecs Cluster props undefined for ${id}`
 
     const ecsCluster = new ecs.Cluster(scope, `${id}`, {
       clusterName: `${props.clusterName}-${scope.props.stage}`,
@@ -78,7 +78,7 @@ export class EcsManager {
     environment?: any,
     secrets?: any
   ) {
-    if (!props) throw `EcsTask props undefined`
+    if (!props) throw `EcsTask props undefined for ${id}`
 
     const ecsTask = new ecs.TaskDefinition(scope, `${id}`, {
       compatibility: ecs.Compatibility.FARGATE,
@@ -135,8 +135,8 @@ export class EcsManager {
     cluster: ecs.ICluster,
     logGroup: logs.ILogGroup
   ) {
-    if (!props) throw `EcsLoadbalanced Fargate Serivice props undefined`
-    if (!props.taskImageOptions) throw `TaskImageOptions for EcsLoadbalanced Fargate Serivice props undefined`
+    if (!props) throw `EcsLoadbalanced Fargate Serivice props undefined for ${id}`
+    if (!props.taskImageOptions) throw `TaskImageOptions for EcsLoadbalanced Fargate Serivice props undefined for ${id}`
 
     const fargateService = new ecsPatterns.ApplicationLoadBalancedFargateService(scope, `${id}-ecs-service`, {
       assignPublicIp: props.assignPublicIp ?? true,

package/src/lib/manager/aws/eks-manager.ts

@@ -41,7 +41,7 @@ export class EksManager {
     image: ecr.DockerImageAsset,
     vpc: ec2.IVpc
   ) {
-    if (!props) throw `EksCluster props undefined`
+    if (!props) throw `EksCluster props undefined for ${id}`
 
     const appLabel = { app: `${id}`.toLowerCase() }
 

package/src/lib/manager/aws/elasticache-manager.ts

@@ -31,13 +31,11 @@ export class ElastiCacheManager {
    * @param {string[]} subnetIds
    */
   public createElastiCacheSubnetGroup(id: string, scope: common.CommonConstruct, subnetIds: string[]) {
-    const elasticacheSubnetGroup = new elasticache.CfnSubnetGroup(scope, `${id}`, {
+    return new elasticache.CfnSubnetGroup(scope, `${id}`, {
       cacheSubnetGroupName: `${id}-subnet-group-${scope.props.stage}`,
       subnetIds: subnetIds,
       description: `${id}-subnet-group-${scope.props.stage}`,
     })
-
-    return elasticacheSubnetGroup
   }
 
   /**
@@ -57,7 +55,7 @@ export class ElastiCacheManager {
     securityGroupIds: string[],
     logDeliveryConfigurations?: any
   ) {
-    if (!props) throw `ElastiCache props undefined`
+    if (!props) throw `ElastiCache props undefined for ${id}`
 
     const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds)
 
@@ -83,7 +81,7 @@ export class ElastiCacheManager {
       logDeliveryConfigurations: logDeliveryConfigurations,
     })
 
-    elasticacheCluster.addDependsOn(subnetGroup)
+    elasticacheCluster.addDependency(subnetGroup)
 
     utils.createCfnOutput(`${id}-clusterName`, scope, elasticacheCluster.clusterName)
     utils.createCfnOutput(`${id}-redisEndpointPort`, scope, elasticacheCluster.attrRedisEndpointPort)
@@ -109,7 +107,7 @@ export class ElastiCacheManager {
     securityGroupIds: string[],
     logDeliveryConfigurations?: any
   ) {
-    if (!props) throw `ElastiCache props undefined`
+    if (!props) throw `ElastiCache props undefined for ${id}`
 
     const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds)
 
@@ -137,7 +135,7 @@ export class ElastiCacheManager {
       autoMinorVersionUpgrade: props.autoMinorVersionUpgrade,
     })
 
-    elasticacheCluster.addDependsOn(subnetGroup)
+    elasticacheCluster.addDependency(subnetGroup)
 
     utils.createCfnOutput(`${id}-primaryEndPointPort`, scope, elasticacheCluster.attrPrimaryEndPointPort)
     utils.createCfnOutput(`${id}-primaryEndPointAddress`, scope, elasticacheCluster.attrPrimaryEndPointAddress)

package/src/lib/manager/aws/event-manager.ts

@@ -34,7 +34,7 @@ export class EventManager {
    * @param {types.EventBusProps} props event bus properties
    */
   public createEventBus(id: string, scope: common.CommonConstruct, props: types.EventBusProps) {
-    if (!props) throw 'EventBus props undefined'
+    if (!props) throw `EventBus props undefined for ${id}`
 
     const eventBus = new events.EventBus(scope, `${id}`, {
       eventBusName: `${props.eventBusName}-${scope.props.stage}`,
@@ -61,7 +61,7 @@ export class EventManager {
     eventBus?: events.IEventBus,
     targets?: events.IRuleTarget[]
   ) {
-    if (!props) throw `EventRule props undefined`
+    if (!props) throw `EventRule props undefined for ${id}`
 
     const rule = new events.Rule(scope, `${id}`, {
       eventBus: eventBus,
@@ -103,7 +103,7 @@ export class EventManager {
     eventPattern?: any,
     scheduleExpression?: string
   ) {
-    if (!props) throw `EventRule props undefined`
+    if (!props) throw `EventRule props undefined for ${id}`
 
     const eventRule = new events.CfnRule(scope, `${id}`, {
       description: 'Rule to send notification to lambda function target',
@@ -149,7 +149,7 @@ export class EventManager {
     role: iam.Role | iam.CfnRole,
     eventPattern?: any
   ) {
-    if (!props) throw `EventRule props undefined`
+    if (!props) throw `EventRule props undefined for ${id}`
 
     const eventRule = new events.CfnRule(scope, `${id}`, {
       description: 'Rule to send notification on new objects in data bucket to ecs task target',

package/src/lib/manager/aws/kms-manager.ts

@@ -31,7 +31,7 @@ export class KmsManager {
    * @param {types.AcmProps} props KMS key props
    */
   public createKey(id: string, scope: common.CommonConstruct, props: types.KmsKeyProps) {
-    if (!props) throw `KMS Key props undefined`
+    if (!props) throw `KMS Key props undefined for ${id}`
 
     const key = new kms.Key(scope, `${id}`, {
       description: props.description,

package/src/lib/manager/aws/lambda-manager.ts

@@ -244,4 +244,40 @@ export class LambdaManager {
 
     return lambdaFunction
   }
+
+  /**
+   * @summary Method to create a lambda function Alias
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.LambdaAliasProps} props
+   * @param {types.LambdaAliasProps} lambdaVersion
+   */
+  public createLambdaFunctionAlias(
+    id: string,
+    scope: common.CommonConstruct,
+    props: types.LambdaAliasProps,
+    lambdaVersion: lambda.IVersion
+  ) {
+    if (!props) throw `Lambda Alias props undefined for ${id}`
+
+    const lambdaFunctionAlias = new lambda.Alias(scope, `${id}`, {
+      ...props,
+      ...{
+        aliasName: `${id}-lambda-alias`,
+        version: lambdaVersion,
+        additionalVersions: props.additionalVersions,
+        description: props.description,
+        maxEventAge: props.maxEventAge,
+        onFailure: props.onFailure,
+        onSuccess: props.onSuccess,
+        provisionedConcurrentExecutions: props.provisionedConcurrentExecutions,
+        retryAttempts: props.retryAttempts,
+      },
+    })
+
+    utils.createCfnOutput(`${id}-lambdaAliasName`, scope, lambdaFunctionAlias.functionArn)
+    utils.createCfnOutput(`${id}-lambdaAliasArn`, scope, lambdaFunctionAlias.functionName)
+
+    return lambdaFunctionAlias
+  }
 }

package/src/lib/manager/aws/log-manager.ts

@@ -38,7 +38,7 @@ export class LogManager {
     props: types.MetricFilterProps,
     logGroup: logs.ILogGroup
   ) {
-    if (!props) throw `MetricFilter props undefined`
+    if (!props) throw `MetricFilter props undefined for ${id}`
 
     const metricFilter = new logs.MetricFilter(scope, `${id}`, {
       logGroup: logGroup,
@@ -67,7 +67,7 @@ export class LogManager {
    * @param {types.LogProps} props
    */
   public createCfnLogGroup(id: string, scope: common.CommonConstruct, props: types.LogProps) {
-    if (!props) throw `Logs props undefined`
+    if (!props) throw `Logs props undefined for ${id}`
 
     const logGroup = new logs.CfnLogGroup(scope, `${id}`, {
       logGroupName: `${props.logGroupName}-${scope.props.stage}`,
@@ -86,7 +86,7 @@ export class LogManager {
    * @param {types.LogProps} props
    */
   public createLogGroup(id: string, scope: common.CommonConstruct, props: types.LogProps) {
-    if (!props) throw `Logs props undefined`
+    if (!props) throw `Logs props undefined for ${id}`
 
     const logGroup = new logs.LogGroup(scope, `${id}`, {
       logGroupName: `${props.logGroupName}-${scope.props.stage}`,

package/src/lib/manager/aws/route53-manager.ts

@@ -36,7 +36,7 @@ export class Route53Manager {
   public createHostedZone(id: string, scope: common.CommonConstruct, props: types.Route53Props) {
     let hostedZone: route53.IHostedZone
 
-    if (!props) throw `Route53 props undefined`
+    if (!props) throw `Route53 props undefined for ${id}`
 
     if (props.useExistingHostedZone) {
       hostedZone = route53.HostedZone.fromLookup(scope, `${id}`, {
@@ -102,8 +102,8 @@ export class Route53Manager {
     recordName?: string,
     skipStageFromRecord?: boolean
   ) {
-    if (!distribution) throw `Distribution undefined`
-    if (!hostedZone) throw `HostedZone undefined`
+    if (!distribution) throw `Distribution undefined for ${id}`
+    if (!hostedZone) throw `HostedZone undefined for ${id}`
 
     const aRecord = new route53.ARecord(scope, `${id}`, {
       recordName:
@@ -134,8 +134,8 @@ export class Route53Manager {
     hostedZone?: route53.IHostedZone,
     recordName?: string
   ) {
-    if (!distribution) throw `Distribution undefined`
-    if (!hostedZone) throw `HostedZone undefined`
+    if (!distribution) throw `Distribution undefined for ${id}`
+    if (!hostedZone) throw `HostedZone undefined for ${id}`
 
     const aRecord = new route53.ARecord(scope, `${id}`, {
       recordName: recordName,

package/src/lib/manager/aws/s3-manager.ts

@@ -89,7 +89,7 @@ export class S3Manager {
    * @param {types.S3BucketProps} props bucket properties
    */
   public createS3Bucket(id: string, scope: common.CommonConstruct, props: types.S3BucketProps) {
-    if (!props) throw `S3 props undefined`
+    if (!props) throw `S3 props undefined for ${id}`
 
     let bucket: s3.IBucket