@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

package/lib/utilities/observability/observability.js

@@ -0,0 +1,278 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerlessObservability = void 0;
+const cdk = require("aws-cdk-lib");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const iam = require("aws-cdk-lib/aws-iam");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const logs = require("aws-cdk-lib/aws-logs");
+const constructs_1 = require("constructs");
+/**
+ * Comprehensive observability construct for serverless use cases
+ */
+class ServerlessObservability extends constructs_1.Construct {
+    constructor(scope, id, resources, config = {}) {
+        super(scope, id);
+        // Configuration with defaults
+        const observabilityConfig = {
+            enableDashboard: true,
+            enableAlarms: true,
+            enableTracing: true,
+            logRetentionDays: logs.RetentionDays.ONE_MONTH,
+            dashboardName: `${resources.useCaseName}-${cdk.Stack.of(this).stackName}`,
+            metricsNamespace: resources.useCaseName,
+            ...config,
+        };
+        this.metricsNamespace = observabilityConfig.metricsNamespace;
+        this.logGroups = [];
+        this.alarms = [];
+        // Create log groups for Lambda functions
+        this.createLogGroups(resources.lambdaFunctions, observabilityConfig);
+        // Enable X-Ray tracing
+        if (observabilityConfig.enableTracing) {
+            this.enableTracing(resources);
+        }
+        // Create CloudWatch alarms
+        if (observabilityConfig.enableAlarms) {
+            this.createAlarms(resources, observabilityConfig);
+        }
+        // Create CloudWatch dashboard
+        if (observabilityConfig.enableDashboard) {
+            this.dashboard = this.createDashboard(resources, observabilityConfig);
+        }
+    }
+    /**
+     * Create log groups for Lambda functions with proper retention
+     */
+    createLogGroups(lambdaFunctions, config) {
+        lambdaFunctions.forEach((fn, index) => {
+            const logGroup = new logs.LogGroup(this, `LogGroup-${index}`, {
+                logGroupName: `/aws/lambda/${fn.functionName}`,
+                retention: config.logRetentionDays,
+                removalPolicy: cdk.RemovalPolicy.DESTROY,
+            });
+            this.logGroups.push(logGroup);
+        });
+    }
+    /**
+     * Enable AWS X-Ray tracing for all resources
+     */
+    enableTracing(resources) {
+        // Enable X-Ray tracing for Lambda functions
+        resources.lambdaFunctions.forEach(fn => {
+            // Enable X-Ray tracing via Lambda configuration (not environment variables)
+            const cfnFunction = fn.node.defaultChild;
+            cfnFunction.tracingConfig = {
+                mode: lambda.Tracing.ACTIVE,
+            };
+            // Add X-Ray permissions
+            fn.addToRolePolicy(new iam.PolicyStatement({
+                actions: ['xray:PutTraceSegments', 'xray:PutTelemetryRecords'],
+                resources: ['*'],
+            }));
+            // Note: _X_AMZN_TRACE_ID is automatically managed by Lambda runtime
+        });
+        // Enable tracing for Step Functions
+        // Note: Tracing should be enabled during state machine creation with tracingEnabled: true
+    }
+    /**
+     * Create CloudWatch alarms for monitoring critical metrics
+     */
+    createAlarms(resources, config) {
+        // Step Functions execution failure alarm (if state machine exists)
+        if (resources.stateMachine) {
+            const stepFunctionFailureAlarm = new cloudwatch.Alarm(this, 'StepFunctionFailureAlarm', {
+                alarmName: `${config.dashboardName}-StepFunction-Failures`,
+                alarmDescription: 'Step Function execution failures',
+                metric: resources.stateMachine.metricFailed({
+                    period: cdk.Duration.minutes(5),
+                    statistic: 'Sum',
+                }),
+                threshold: 1,
+                evaluationPeriods: 1,
+                treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+            });
+            this.alarms.push(stepFunctionFailureAlarm);
+        }
+        // Lambda function error rate alarms
+        resources.lambdaFunctions.forEach((fn, index) => {
+            const errorAlarm = new cloudwatch.Alarm(this, `LambdaErrorAlarm-${index}`, {
+                alarmName: `${config.dashboardName}-Lambda-${fn.functionName}-Errors`,
+                alarmDescription: `High error rate for Lambda function ${fn.functionName}`,
+                metric: fn.metricErrors({
+                    period: cdk.Duration.minutes(5),
+                    statistic: 'Sum',
+                }),
+                threshold: 5,
+                evaluationPeriods: 2,
+                treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+            });
+            this.alarms.push(errorAlarm);
+            // Lambda function duration alarm
+            const durationAlarm = new cloudwatch.Alarm(this, `LambdaDurationAlarm-${index}`, {
+                alarmName: `${config.dashboardName}-Lambda-${fn.functionName}-Duration`,
+                alarmDescription: `High duration for Lambda function ${fn.functionName}`,
+                metric: fn.metricDuration({
+                    period: cdk.Duration.minutes(5),
+                    statistic: 'Average',
+                }),
+                threshold: 30000, // 30 seconds
+                evaluationPeriods: 3,
+                treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+            });
+            this.alarms.push(durationAlarm);
+        });
+        // SQS queue depth alarm (if queues exist)
+        if (resources.sqsQueues) {
+            resources.sqsQueues.forEach((queue, index) => {
+                const queueDepthAlarm = new cloudwatch.Alarm(this, `SQSDepthAlarm-${index}`, {
+                    alarmName: `${config.dashboardName}-SQS-${queue.queueName}-Depth`,
+                    alarmDescription: `High message count in SQS queue ${queue.queueName}`,
+                    metric: queue.metricApproximateNumberOfMessagesVisible({
+                        period: cdk.Duration.minutes(5),
+                        statistic: 'Average',
+                    }),
+                    threshold: 100,
+                    evaluationPeriods: 2,
+                    treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+                });
+                this.alarms.push(queueDepthAlarm);
+            });
+        }
+        // Dead letter queue alarm
+        if (resources.deadLetterQueue) {
+            const dlqAlarm = new cloudwatch.Alarm(this, 'DeadLetterQueueAlarm', {
+                alarmName: `${config.dashboardName}-DeadLetterQueue-Messages`,
+                alarmDescription: 'Messages in dead letter queue',
+                metric: resources.deadLetterQueue.metricApproximateNumberOfMessagesVisible({
+                    period: cdk.Duration.minutes(5),
+                    statistic: 'Sum',
+                }),
+                threshold: 1,
+                evaluationPeriods: 1,
+                treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+            });
+            this.alarms.push(dlqAlarm);
+        }
+    }
+    /**
+     * Create comprehensive CloudWatch dashboard
+     */
+    createDashboard(resources, config) {
+        const dashboard = new cloudwatch.Dashboard(this, 'Dashboard', {
+            dashboardName: config.dashboardName,
+        });
+        // Step Functions metrics (if state machine exists)
+        if (resources.stateMachine) {
+            dashboard.addWidgets(new cloudwatch.GraphWidget({
+                title: 'Step Functions Executions',
+                left: [
+                    resources.stateMachine.metricStarted({
+                        label: 'Started',
+                        color: cloudwatch.Color.BLUE,
+                    }),
+                    resources.stateMachine.metricSucceeded({
+                        label: 'Succeeded',
+                        color: cloudwatch.Color.GREEN,
+                    }),
+                    resources.stateMachine.metricFailed({
+                        label: 'Failed',
+                        color: cloudwatch.Color.RED,
+                    }),
+                ],
+                width: 12,
+                height: 6,
+            }));
+            dashboard.addWidgets(new cloudwatch.GraphWidget({
+                title: 'Step Functions Execution Duration',
+                left: [
+                    resources.stateMachine.metricTime({
+                        label: 'Execution Time',
+                        statistic: 'Average',
+                        color: cloudwatch.Color.PURPLE,
+                    }),
+                ],
+                width: 12,
+                height: 6,
+            }));
+        }
+        // Lambda functions metrics
+        const lambdaInvocations = resources.lambdaFunctions.map(fn => fn.metricInvocations({
+            label: fn.functionName,
+        }));
+        const lambdaErrors = resources.lambdaFunctions.map(fn => fn.metricErrors({
+            label: `${fn.functionName} Errors`,
+            color: cloudwatch.Color.RED,
+        }));
+        dashboard.addWidgets(new cloudwatch.GraphWidget({
+            title: 'Lambda Function Invocations',
+            left: lambdaInvocations,
+            width: 12,
+            height: 6,
+        }));
+        dashboard.addWidgets(new cloudwatch.GraphWidget({
+            title: 'Lambda Function Errors',
+            left: lambdaErrors,
+            width: 12,
+            height: 6,
+        }));
+        // SQS queue metrics (if queues exist)
+        if (resources.sqsQueues && resources.sqsQueues.length > 0) {
+            const sqsMessages = resources.sqsQueues.map(queue => queue.metricApproximateNumberOfMessagesVisible({
+                label: `${queue.queueName} Messages`,
+            }));
+            dashboard.addWidgets(new cloudwatch.GraphWidget({
+                title: 'SQS Queue Depth',
+                left: sqsMessages,
+                width: 12,
+                height: 6,
+            }));
+        }
+        // Custom metrics widget for use case specific metrics
+        dashboard.addWidgets(new cloudwatch.GraphWidget({
+            title: `${resources.useCaseName} Metrics`,
+            left: [
+                new cloudwatch.Metric({
+                    namespace: this.metricsNamespace,
+                    metricName: 'ProcessedItems',
+                    statistic: 'Sum',
+                    label: 'Items Processed',
+                    color: cloudwatch.Color.GREEN,
+                }),
+                new cloudwatch.Metric({
+                    namespace: this.metricsNamespace,
+                    metricName: 'FailedItems',
+                    statistic: 'Sum',
+                    label: 'Items Failed',
+                    color: cloudwatch.Color.RED,
+                }),
+            ],
+            width: 12,
+            height: 6,
+        }));
+        return dashboard;
+    }
+    /**
+     * Add custom widget to the dashboard
+     */
+    addCustomWidget(widget) {
+        if (this.dashboard) {
+            this.dashboard.addWidgets(widget);
+        }
+    }
+    /**
+     * Create a custom metric for use case specific events
+     */
+    createCustomMetric(metricName, dimensionsMap) {
+        return new cloudwatch.Metric({
+            namespace: this.metricsNamespace,
+            metricName,
+            dimensionsMap,
+            statistic: 'Sum',
+        });
+    }
+}
+exports.ServerlessObservability = ServerlessObservability;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observability.js","sourceRoot":"","sources":["../../../use-cases/utilities/observability/observability.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as cdk from 'aws-cdk-lib';\nimport * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as sqs from 'aws-cdk-lib/aws-sqs';\nimport * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions';\nimport { Construct } from 'constructs';\n\n/**\n * Configuration for observability features\n */\nexport interface ObservabilityConfig {\n  /** Enable CloudWatch Dashboard */\n  readonly enableDashboard?: boolean;\n\n  /** Enable CloudWatch Alarms */\n  readonly enableAlarms?: boolean;\n\n  /** Enable AWS X-Ray tracing */\n  readonly enableTracing?: boolean;\n\n  /** Log retention period in days */\n  readonly logRetentionDays?: logs.RetentionDays;\n\n  /** Custom dashboard name */\n  readonly dashboardName?: string;\n\n  /** SNS topic ARN for alarm notifications */\n  readonly alarmNotificationTopicArn?: string;\n\n  /** Custom metric namespace */\n  readonly metricsNamespace?: string;\n}\n\n/**\n * Resources that need observability monitoring\n */\nexport interface ObservabilityResources {\n  /** Step Functions state machine (optional) */\n  readonly stateMachine?: stepfunctions.StateMachine;\n\n  /** Lambda functions to monitor */\n  readonly lambdaFunctions: lambda.Function[];\n\n  /** SQS queues to monitor (optional) */\n  readonly sqsQueues?: sqs.Queue[];\n\n  /** S3 buckets for storage (optional) */\n  readonly s3Buckets?: s3.IBucket[];\n\n  /** Dead letter queue (optional) */\n  readonly deadLetterQueue?: sqs.IQueue;\n\n  /** Use case name for labeling */\n  readonly useCaseName: string;\n}\n\n/**\n * Comprehensive observability construct for serverless use cases\n */\nexport class ServerlessObservability extends Construct {\n  /** CloudWatch Dashboard for monitoring */\n  public readonly dashboard?: cloudwatch.Dashboard;\n\n  /** CloudWatch Log Groups */\n  public readonly logGroups: logs.LogGroup[];\n\n  /** CloudWatch Alarms */\n  public readonly alarms: cloudwatch.Alarm[];\n\n  /** Metrics namespace */\n  public readonly metricsNamespace: string;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    resources: ObservabilityResources,\n    config: ObservabilityConfig = {},\n  ) {\n    super(scope, id);\n\n    // Configuration with defaults\n    const observabilityConfig = {\n      enableDashboard: true,\n      enableAlarms: true,\n      enableTracing: true,\n      logRetentionDays: logs.RetentionDays.ONE_MONTH,\n      dashboardName: `${resources.useCaseName}-${cdk.Stack.of(this).stackName}`,\n      metricsNamespace: resources.useCaseName,\n      ...config,\n    };\n\n    this.metricsNamespace = observabilityConfig.metricsNamespace;\n    this.logGroups = [];\n    this.alarms = [];\n\n    // Create log groups for Lambda functions\n    this.createLogGroups(resources.lambdaFunctions, observabilityConfig);\n\n    // Enable X-Ray tracing\n    if (observabilityConfig.enableTracing) {\n      this.enableTracing(resources);\n    }\n\n    // Create CloudWatch alarms\n    if (observabilityConfig.enableAlarms) {\n      this.createAlarms(resources, observabilityConfig);\n    }\n\n    // Create CloudWatch dashboard\n    if (observabilityConfig.enableDashboard) {\n      this.dashboard = this.createDashboard(resources, observabilityConfig);\n    }\n  }\n\n  /**\n   * Create log groups for Lambda functions with proper retention\n   */\n  private createLogGroups(\n    lambdaFunctions: lambda.Function[],\n    config: ObservabilityConfig,\n  ): void {\n    lambdaFunctions.forEach((fn, index) => {\n      const logGroup = new logs.LogGroup(this, `LogGroup-${index}`, {\n        logGroupName: `/aws/lambda/${fn.functionName}`,\n        retention: config.logRetentionDays!,\n        removalPolicy: cdk.RemovalPolicy.DESTROY,\n      });\n\n      this.logGroups.push(logGroup);\n    });\n  }\n\n  /**\n   * Enable AWS X-Ray tracing for all resources\n   */\n  private enableTracing(resources: ObservabilityResources): void {\n    // Enable X-Ray tracing for Lambda functions\n    resources.lambdaFunctions.forEach(fn => {\n      // Enable X-Ray tracing via Lambda configuration (not environment variables)\n      const cfnFunction = fn.node.defaultChild as lambda.CfnFunction;\n      cfnFunction.tracingConfig = {\n        mode: lambda.Tracing.ACTIVE,\n      };\n\n      // Add X-Ray permissions\n      fn.addToRolePolicy(new iam.PolicyStatement({\n        actions: ['xray:PutTraceSegments', 'xray:PutTelemetryRecords'],\n        resources: ['*'],\n      }));\n\n      // Note: _X_AMZN_TRACE_ID is automatically managed by Lambda runtime\n    });\n\n    // Enable tracing for Step Functions\n    // Note: Tracing should be enabled during state machine creation with tracingEnabled: true\n  }\n\n  /**\n   * Create CloudWatch alarms for monitoring critical metrics\n   */\n  private createAlarms(\n    resources: ObservabilityResources,\n    config: ObservabilityConfig,\n  ): void {\n    // Step Functions execution failure alarm (if state machine exists)\n    if (resources.stateMachine) {\n      const stepFunctionFailureAlarm = new cloudwatch.Alarm(this, 'StepFunctionFailureAlarm', {\n        alarmName: `${config.dashboardName}-StepFunction-Failures`,\n        alarmDescription: 'Step Function execution failures',\n        metric: resources.stateMachine.metricFailed({\n          period: cdk.Duration.minutes(5),\n          statistic: 'Sum',\n        }),\n        threshold: 1,\n        evaluationPeriods: 1,\n        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n      });\n      this.alarms.push(stepFunctionFailureAlarm);\n    }\n\n    // Lambda function error rate alarms\n    resources.lambdaFunctions.forEach((fn, index) => {\n      const errorAlarm = new cloudwatch.Alarm(this, `LambdaErrorAlarm-${index}`, {\n        alarmName: `${config.dashboardName}-Lambda-${fn.functionName}-Errors`,\n        alarmDescription: `High error rate for Lambda function ${fn.functionName}`,\n        metric: fn.metricErrors({\n          period: cdk.Duration.minutes(5),\n          statistic: 'Sum',\n        }),\n        threshold: 5,\n        evaluationPeriods: 2,\n        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n      });\n      this.alarms.push(errorAlarm);\n\n      // Lambda function duration alarm\n      const durationAlarm = new cloudwatch.Alarm(this, `LambdaDurationAlarm-${index}`, {\n        alarmName: `${config.dashboardName}-Lambda-${fn.functionName}-Duration`,\n        alarmDescription: `High duration for Lambda function ${fn.functionName}`,\n        metric: fn.metricDuration({\n          period: cdk.Duration.minutes(5),\n          statistic: 'Average',\n        }),\n        threshold: 30000, // 30 seconds\n        evaluationPeriods: 3,\n        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n      });\n      this.alarms.push(durationAlarm);\n    });\n\n    // SQS queue depth alarm (if queues exist)\n    if (resources.sqsQueues) {\n      resources.sqsQueues.forEach((queue, index) => {\n        const queueDepthAlarm = new cloudwatch.Alarm(this, `SQSDepthAlarm-${index}`, {\n          alarmName: `${config.dashboardName}-SQS-${queue.queueName}-Depth`,\n          alarmDescription: `High message count in SQS queue ${queue.queueName}`,\n          metric: queue.metricApproximateNumberOfMessagesVisible({\n            period: cdk.Duration.minutes(5),\n            statistic: 'Average',\n          }),\n          threshold: 100,\n          evaluationPeriods: 2,\n          treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n        });\n        this.alarms.push(queueDepthAlarm);\n      });\n    }\n\n    // Dead letter queue alarm\n    if (resources.deadLetterQueue) {\n      const dlqAlarm = new cloudwatch.Alarm(this, 'DeadLetterQueueAlarm', {\n        alarmName: `${config.dashboardName}-DeadLetterQueue-Messages`,\n        alarmDescription: 'Messages in dead letter queue',\n        metric: resources.deadLetterQueue.metricApproximateNumberOfMessagesVisible({\n          period: cdk.Duration.minutes(5),\n          statistic: 'Sum',\n        }),\n        threshold: 1,\n        evaluationPeriods: 1,\n        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n      });\n      this.alarms.push(dlqAlarm);\n    }\n  }\n\n  /**\n   * Create comprehensive CloudWatch dashboard\n   */\n  private createDashboard(\n    resources: ObservabilityResources,\n    config: ObservabilityConfig,\n  ): cloudwatch.Dashboard {\n    const dashboard = new cloudwatch.Dashboard(this, 'Dashboard', {\n      dashboardName: config.dashboardName,\n    });\n\n    // Step Functions metrics (if state machine exists)\n    if (resources.stateMachine) {\n      dashboard.addWidgets(\n        new cloudwatch.GraphWidget({\n          title: 'Step Functions Executions',\n          left: [\n            resources.stateMachine.metricStarted({\n              label: 'Started',\n              color: cloudwatch.Color.BLUE,\n            }),\n            resources.stateMachine.metricSucceeded({\n              label: 'Succeeded',\n              color: cloudwatch.Color.GREEN,\n            }),\n            resources.stateMachine.metricFailed({\n              label: 'Failed',\n              color: cloudwatch.Color.RED,\n            }),\n          ],\n          width: 12,\n          height: 6,\n        }),\n      );\n\n      dashboard.addWidgets(\n        new cloudwatch.GraphWidget({\n          title: 'Step Functions Execution Duration',\n          left: [\n            resources.stateMachine.metricTime({\n              label: 'Execution Time',\n              statistic: 'Average',\n              color: cloudwatch.Color.PURPLE,\n            }),\n          ],\n          width: 12,\n          height: 6,\n        }),\n      );\n    }\n\n    // Lambda functions metrics\n    const lambdaInvocations = resources.lambdaFunctions.map(fn =>\n      fn.metricInvocations({\n        label: fn.functionName,\n      }),\n    );\n\n    const lambdaErrors = resources.lambdaFunctions.map(fn =>\n      fn.metricErrors({\n        label: `${fn.functionName} Errors`,\n        color: cloudwatch.Color.RED,\n      }),\n    );\n\n    dashboard.addWidgets(\n      new cloudwatch.GraphWidget({\n        title: 'Lambda Function Invocations',\n        left: lambdaInvocations,\n        width: 12,\n        height: 6,\n      }),\n    );\n\n    dashboard.addWidgets(\n      new cloudwatch.GraphWidget({\n        title: 'Lambda Function Errors',\n        left: lambdaErrors,\n        width: 12,\n        height: 6,\n      }),\n    );\n\n    // SQS queue metrics (if queues exist)\n    if (resources.sqsQueues && resources.sqsQueues.length > 0) {\n      const sqsMessages = resources.sqsQueues.map(queue =>\n        queue.metricApproximateNumberOfMessagesVisible({\n          label: `${queue.queueName} Messages`,\n        }),\n      );\n\n      dashboard.addWidgets(\n        new cloudwatch.GraphWidget({\n          title: 'SQS Queue Depth',\n          left: sqsMessages,\n          width: 12,\n          height: 6,\n        }),\n      );\n    }\n\n    // Custom metrics widget for use case specific metrics\n    dashboard.addWidgets(\n      new cloudwatch.GraphWidget({\n        title: `${resources.useCaseName} Metrics`,\n        left: [\n          new cloudwatch.Metric({\n            namespace: this.metricsNamespace,\n            metricName: 'ProcessedItems',\n            statistic: 'Sum',\n            label: 'Items Processed',\n            color: cloudwatch.Color.GREEN,\n          }),\n          new cloudwatch.Metric({\n            namespace: this.metricsNamespace,\n            metricName: 'FailedItems',\n            statistic: 'Sum',\n            label: 'Items Failed',\n            color: cloudwatch.Color.RED,\n          }),\n        ],\n        width: 12,\n        height: 6,\n      }),\n    );\n\n    return dashboard;\n  }\n\n  /**\n   * Add custom widget to the dashboard\n   */\n  public addCustomWidget(widget: cloudwatch.IWidget): void {\n    if (this.dashboard) {\n      this.dashboard.addWidgets(widget);\n    }\n  }\n\n  /**\n   * Create a custom metric for use case specific events\n   */\n  public createCustomMetric(\n    metricName: string,\n    dimensionsMap?: { [key: string]: string },\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: this.metricsNamespace,\n      metricName,\n      dimensionsMap,\n      statistic: 'Sum',\n    });\n  }\n}\n"]}

package/lib/utilities/observability/observable.d.ts

@@ -0,0 +1,32 @@
+import { IMetric } from 'aws-cdk-lib/aws-cloudwatch';
+import { LogGroupDataProtectionProps } from './log-group-data-protection-props';
+/**
+ * Additional properties that constructs implementing the IObservable
+ * interface should extend as part of their input props
+ */
+export interface ObservableProps {
+    /**
+     * Business metric service name dimension
+     * @default would be defined per use case
+     */
+    readonly metricServiceName?: string;
+    /**
+     * Business metric namespace
+     * @default would be defined per use case
+     */
+    readonly metricNamespace?: string;
+    /**
+     * Data protection related configuration
+     * @default a new KMS key would be generated
+     */
+    readonly logGroupDataProtection?: LogGroupDataProtectionProps;
+}
+/**
+ * Interface providing configuration parameters for constructs that support Observability
+ */
+export interface IObservable {
+    readonly metricServiceName: string;
+    readonly metricNamespace: string;
+    readonly logGroupDataProtection: LogGroupDataProtectionProps;
+    metrics(): IMetric[];
+}

package/lib/utilities/observability/observable.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JzZXJ2YWJsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3VzZS1jYXNlcy91dGlsaXRpZXMvb2JzZXJ2YWJpbGl0eS9vYnNlcnZhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgQW1hem9uLmNvbSwgSW5jLiBvciBpdHMgYWZmaWxpYXRlcy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5pbXBvcnQgeyBJTWV0cmljIH0gZnJvbSAnYXdzLWNkay1saWIvYXdzLWNsb3Vkd2F0Y2gnO1xuaW1wb3J0IHsgTG9nR3JvdXBEYXRhUHJvdGVjdGlvblByb3BzIH0gZnJvbSAnLi9sb2ctZ3JvdXAtZGF0YS1wcm90ZWN0aW9uLXByb3BzJztcblxuLyoqXG4gKiBBZGRpdGlvbmFsIHByb3BlcnRpZXMgdGhhdCBjb25zdHJ1Y3RzIGltcGxlbWVudGluZyB0aGUgSU9ic2VydmFibGVcbiAqIGludGVyZmFjZSBzaG91bGQgZXh0ZW5kIGFzIHBhcnQgb2YgdGhlaXIgaW5wdXQgcHJvcHNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBPYnNlcnZhYmxlUHJvcHMge1xuICAvKipcbiAgICogQnVzaW5lc3MgbWV0cmljIHNlcnZpY2UgbmFtZSBkaW1lbnNpb25cbiAgICogQGRlZmF1bHQgd291bGQgYmUgZGVmaW5lZCBwZXIgdXNlIGNhc2VcbiAgICovXG4gIHJlYWRvbmx5IG1ldHJpY1NlcnZpY2VOYW1lPzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBCdXNpbmVzcyBtZXRyaWMgbmFtZXNwYWNlXG4gICAqIEBkZWZhdWx0IHdvdWxkIGJlIGRlZmluZWQgcGVyIHVzZSBjYXNlXG4gICAqL1xuICByZWFkb25seSBtZXRyaWNOYW1lc3BhY2U/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIERhdGEgcHJvdGVjdGlvbiByZWxhdGVkIGNvbmZpZ3VyYXRpb25cbiAgICogQGRlZmF1bHQgYSBuZXcgS01TIGtleSB3b3VsZCBiZSBnZW5lcmF0ZWRcbiAgICovXG4gIHJlYWRvbmx5IGxvZ0dyb3VwRGF0YVByb3RlY3Rpb24/OiBMb2dHcm91cERhdGFQcm90ZWN0aW9uUHJvcHM7XG59XG5cbi8qKlxuICogSW50ZXJmYWNlIHByb3ZpZGluZyBjb25maWd1cmF0aW9uIHBhcmFtZXRlcnMgZm9yIGNvbnN0cnVjdHMgdGhhdCBzdXBwb3J0IE9ic2VydmFiaWxpdHlcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJT2JzZXJ2YWJsZSB7XG4gIHJlYWRvbmx5IG1ldHJpY1NlcnZpY2VOYW1lOiBzdHJpbmc7XG4gIHJlYWRvbmx5IG1ldHJpY05hbWVzcGFjZTogc3RyaW5nO1xuICByZWFkb25seSBsb2dHcm91cERhdGFQcm90ZWN0aW9uOiBMb2dHcm91cERhdGFQcm90ZWN0aW9uUHJvcHM7XG5cbiAgbWV0cmljcygpOiBJTWV0cmljW107XG59Il19

package/lib/utilities/observability/powertools-config.d.ts

@@ -0,0 +1,3 @@
+export declare class PowertoolsConfig {
+    static generateDefaultLambdaConfig(enableObservability?: boolean, metricsNamespace?: string, serviceName?: string): Record<string, string>;
+}

package/lib/utilities/observability/powertools-config.js

@@ -0,0 +1,25 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowertoolsConfig = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+class PowertoolsConfig {
+    static generateDefaultLambdaConfig(enableObservability = false, metricsNamespace = 'appmod-catalog', serviceName = 'appmod-catalog-service') {
+        if (enableObservability) {
+            return {
+                POWERTOOLS_METRICS_NAMESPACE: metricsNamespace,
+                POWERTOOLS_SERVICE_NAME: serviceName,
+            };
+        }
+        else {
+            return {
+                POWERTOOLS_METRICS_DISABLED: 'true',
+                POWERTOOLS_TRACE_DISABLED: 'true',
+            };
+        }
+    }
+}
+exports.PowertoolsConfig = PowertoolsConfig;
+_a = JSII_RTTI_SYMBOL_1;
+PowertoolsConfig[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.PowertoolsConfig", version: "1.0.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG93ZXJ0b29scy1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi91c2UtY2FzZXMvdXRpbGl0aWVzL29ic2VydmFiaWxpdHkvcG93ZXJ0b29scy1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxNQUFhLGdCQUFnQjtJQUNwQixNQUFNLENBQUMsMkJBQTJCLENBQUMsc0JBQStCLEtBQUssRUFBRSxtQkFBMkIsZ0JBQWdCLEVBQUUsY0FBc0Isd0JBQXdCO1FBQ3pLLElBQUksbUJBQW1CLEVBQUUsQ0FBQztZQUN4QixPQUFPO2dCQUNMLDRCQUE0QixFQUFFLGdCQUFnQjtnQkFDOUMsdUJBQXVCLEVBQUUsV0FBVzthQUNyQyxDQUFDO1FBQ0osQ0FBQzthQUFNLENBQUM7WUFDTixPQUFPO2dCQUNMLDJCQUEyQixFQUFFLE1BQU07Z0JBQ25DLHlCQUF5QixFQUFFLE1BQU07YUFDbEMsQ0FBQztRQUNKLENBQUM7SUFDSCxDQUFDOztBQWJILDRDQWNDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFBvd2VydG9vbHNDb25maWcge1xuICBwdWJsaWMgc3RhdGljIGdlbmVyYXRlRGVmYXVsdExhbWJkYUNvbmZpZyhlbmFibGVPYnNlcnZhYmlsaXR5OiBib29sZWFuID0gZmFsc2UsIG1ldHJpY3NOYW1lc3BhY2U6IHN0cmluZyA9ICdhcHBtb2QtY2F0YWxvZycsIHNlcnZpY2VOYW1lOiBzdHJpbmcgPSAnYXBwbW9kLWNhdGFsb2ctc2VydmljZScpOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+IHtcbiAgICBpZiAoZW5hYmxlT2JzZXJ2YWJpbGl0eSkge1xuICAgICAgcmV0dXJuIHtcbiAgICAgICAgUE9XRVJUT09MU19NRVRSSUNTX05BTUVTUEFDRTogbWV0cmljc05hbWVzcGFjZSxcbiAgICAgICAgUE9XRVJUT09MU19TRVJWSUNFX05BTUU6IHNlcnZpY2VOYW1lLFxuICAgICAgfTtcbiAgICB9IGVsc2Uge1xuICAgICAgcmV0dXJuIHtcbiAgICAgICAgUE9XRVJUT09MU19NRVRSSUNTX0RJU0FCTEVEOiAndHJ1ZScsXG4gICAgICAgIFBPV0VSVE9PTFNfVFJBQ0VfRElTQUJMRUQ6ICd0cnVlJyxcbiAgICAgIH07XG4gICAgfVxuICB9XG59Il19

package/lib/utilities/observability/resources/bedrock-manage-logging-configuration/index.py

@@ -0,0 +1,27 @@
+import boto3
+
+client = boto3.client('bedrock')
+
+def handler(event, context):
+    request_type = event['RequestType']
+    
+    # Only process CREATE and UPDATE events
+    if request_type not in ['Create', 'Update']:
+        return
+    
+    current_logging_config = client.get_model_invocation_logging_configuration()
+    
+    # Check if logging is already configured and override is not set
+    if current_logging_config.get('loggingConfig') and not event.get('ResourceProperties', {}).get('override', False):
+        return
+    
+    # Update logging configuration
+    props = event['ResourceProperties']
+    client.put_model_invocation_logging_configuration(
+        loggingConfig={
+            'cloudWatchConfig': {
+                'logGroupName': props['logGroupName'],
+                'roleArn': props['roleArn']
+            }
+        }
+    )

package/lib/utilities/observability/state-machine-observability-property-injector.d.ts

@@ -0,0 +1,8 @@
+import { InjectionContext, IPropertyInjector } from 'aws-cdk-lib';
+import { LogGroupDataProtectionProps } from './log-group-data-protection-props';
+export declare class StateMachineObservabilityPropertyInjector implements IPropertyInjector {
+    readonly constructUniqueId: string;
+    readonly logGroupDataProtection: LogGroupDataProtectionProps;
+    constructor(logGroupDataProtection: LogGroupDataProtectionProps);
+    inject(originalProps: any, _context: InjectionContext): any;
+}

package/lib/utilities/observability/state-machine-observability-property-injector.js

@@ -0,0 +1,49 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachineObservabilityPropertyInjector = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
+class StateMachineObservabilityPropertyInjector {
+    constructor(logGroupDataProtection) {
+        this.constructUniqueId = aws_stepfunctions_1.StateMachine.PROPERTY_INJECTION_ID;
+        this.logGroupDataProtection = logGroupDataProtection;
+    }
+    inject(originalProps, _context) {
+        const namePrefix = aws_cdk_lib_1.Names.uniqueResourceName(_context.scope, {
+            maxLength: 100,
+        });
+        const { region, account } = aws_cdk_lib_1.Stack.of(_context.scope);
+        const logGroupName = `/aws/sfn-statemachine/${namePrefix}-statemachine`;
+        const logGroupArn = `arn:aws:logs:${region}:${account}:log-group:${logGroupName}`;
+        this.logGroupDataProtection.logGroupEncryptionKey?.grantEncryptDecrypt(new aws_iam_1.ServicePrincipal('logs.amazonaws.com', {
+            conditions: {
+                ArnEquals: {
+                    'kms:EncryptionContext:aws:logs:arn': logGroupArn,
+                },
+            },
+        }));
+        return {
+            tracingEnabled: true,
+            logs: {
+                destination: new aws_logs_1.LogGroup(_context.scope, `${_context.id}-LogGroup`, {
+                    logGroupName,
+                    encryptionKey: this.logGroupDataProtection.logGroupEncryptionKey,
+                    dataProtectionPolicy: this.logGroupDataProtection.dataProtectionIdentifiers ? new aws_logs_1.DataProtectionPolicy({
+                        identifiers: this.logGroupDataProtection.dataProtectionIdentifiers,
+                    }) : undefined,
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+                }),
+                level: aws_stepfunctions_1.LogLevel.ALL,
+            },
+            ...originalProps,
+        };
+    }
+}
+exports.StateMachineObservabilityPropertyInjector = StateMachineObservabilityPropertyInjector;
+_a = JSII_RTTI_SYMBOL_1;
+StateMachineObservabilityPropertyInjector[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.StateMachineObservabilityPropertyInjector", version: "1.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utilities/tests/data-loader-nag.test.d.ts

@@ -0,0 +1 @@
+export {};