@stacksjs/ts-cloud-core 0.1.8 → 0.1.9

package/src/modules/monitoring.ts

@@ -0,0 +1,2086 @@
+import type {
+  CloudWatchAlarm,
+  CloudWatchDashboard,
+  CloudWatchLogGroup,
+  CloudWatchLogStream,
+  CloudWatchMetricFilter,
+  CloudWatchCompositeAlarm,
+} from '@stacksjs/ts-cloud-aws-types'
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types'
+import { Fn } from '../intrinsic-functions'
+import { generateLogicalId, generateResourceName } from '../resource-naming'
+
+export interface AlarmOptions {
+  slug: string
+  environment: EnvironmentType
+  alarmName?: string
+  metricName: string
+  namespace: string
+  statistic?: 'Average' | 'Sum' | 'Minimum' | 'Maximum' | 'SampleCount'
+  period?: number
+  evaluationPeriods?: number
+  threshold: number
+  comparisonOperator: 'GreaterThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanThreshold' | 'LessThanOrEqualToThreshold'
+  treatMissingData?: 'breaching' | 'notBreaching' | 'ignore' | 'missing'
+  actionsEnabled?: boolean
+  alarmActions?: string[]
+  okActions?: string[]
+  insufficientDataActions?: string[]
+  dimensions?: Record<string, string>
+  unit?: string
+  datapointsToAlarm?: number
+}
+
+export interface DashboardOptions {
+  slug: string
+  environment: EnvironmentType
+  dashboardName?: string
+  widgets: DashboardWidget[]
+}
+
+export interface DashboardWidget {
+  type: 'metric' | 'log' | 'text' | 'alarm'
+  x: number
+  y: number
+  width: number
+  height: number
+  properties: Record<string, unknown>
+}
+
+export interface LogGroupOptions {
+  slug: string
+  environment: EnvironmentType
+  logGroupName?: string
+  retentionInDays?: number
+  kmsKeyId?: string
+}
+
+export interface LogStreamOptions {
+  slug: string
+  environment: EnvironmentType
+  logStreamName?: string
+}
+
+export interface MetricFilterOptions {
+  slug: string
+  environment: EnvironmentType
+  filterName?: string
+  filterPattern: string
+  metricTransformations: MetricTransformation[]
+}
+
+export interface MetricTransformation {
+  metricName: string
+  metricNamespace: string
+  metricValue: string
+  defaultValue?: number
+  unit?: string
+}
+
+export interface CompositeAlarmOptions {
+  slug: string
+  environment: EnvironmentType
+  alarmName?: string
+  alarmRule: string
+  actionsEnabled?: boolean
+  alarmActions?: string[]
+  okActions?: string[]
+  insufficientDataActions?: string[]
+}
+
+/**
+ * Monitoring Module - CloudWatch
+ * Provides clean API for alarms, dashboards, logs, and metrics
+ */
+export class Monitoring {
+  /**
+   * Create a CloudWatch alarm
+   */
+  static createAlarm(options: AlarmOptions): {
+    alarm: CloudWatchAlarm
+    logicalId: string
+  } {
+    const {
+      slug,
+      environment,
+      alarmName,
+      metricName,
+      namespace,
+      statistic = 'Average',
+      period = 300,
+      evaluationPeriods = 1,
+      threshold,
+      comparisonOperator,
+      treatMissingData = 'notBreaching',
+      actionsEnabled = true,
+      alarmActions,
+      okActions,
+      insufficientDataActions,
+      dimensions,
+      unit,
+      datapointsToAlarm,
+    } = options
+
+    const resourceName = alarmName || generateResourceName({
+      slug,
+      environment,
+      resourceType: 'alarm',
+    })
+
+    const logicalId = generateLogicalId(resourceName)
+
+    const alarm: CloudWatchAlarm = {
+      Type: 'AWS::CloudWatch::Alarm',
+      Properties: {
+        AlarmName: resourceName,
+        MetricName: metricName,
+        Namespace: namespace,
+        Statistic: statistic,
+        Period: period,
+        EvaluationPeriods: evaluationPeriods,
+        Threshold: threshold,
+        ComparisonOperator: comparisonOperator,
+        TreatMissingData: treatMissingData,
+        ActionsEnabled: actionsEnabled,
+      },
+    }
+
+    if (alarmActions && alarmActions.length > 0) {
+      alarm.Properties!.AlarmActions = alarmActions
+    }
+
+    if (okActions && okActions.length > 0) {
+      alarm.Properties!.OKActions = okActions
+    }
+
+    if (insufficientDataActions && insufficientDataActions.length > 0) {
+      alarm.Properties!.InsufficientDataActions = insufficientDataActions
+    }
+
+    if (dimensions) {
+      alarm.Properties!.Dimensions = Object.entries(dimensions).map(([name, value]) => ({
+        Name: name,
+        Value: value,
+      }))
+    }
+
+    if (unit) {
+      alarm.Properties!.Unit = unit
+    }
+
+    if (datapointsToAlarm !== undefined) {
+      alarm.Properties!.DatapointsToAlarm = datapointsToAlarm
+    }
+
+    return { alarm, logicalId }
+  }
+
+  /**
+   * Create a composite alarm (combines multiple alarms)
+   */
+  static createCompositeAlarm(options: CompositeAlarmOptions): {
+    alarm: CloudWatchCompositeAlarm
+    logicalId: string
+  } {
+    const {
+      slug,
+      environment,
+      alarmName,
+      alarmRule,
+      actionsEnabled = true,
+      alarmActions,
+      okActions,
+      insufficientDataActions,
+    } = options
+
+    const resourceName = alarmName || generateResourceName({
+      slug,
+      environment,
+      resourceType: 'composite-alarm',
+    })
+
+    const logicalId = generateLogicalId(resourceName)
+
+    const alarm: CloudWatchCompositeAlarm = {
+      Type: 'AWS::CloudWatch::CompositeAlarm',
+      Properties: {
+        AlarmName: resourceName,
+        AlarmRule: alarmRule,
+        ActionsEnabled: actionsEnabled,
+      },
+    }
+
+    if (alarmActions && alarmActions.length > 0) {
+      alarm.Properties!.AlarmActions = alarmActions
+    }
+
+    if (okActions && okActions.length > 0) {
+      alarm.Properties!.OKActions = okActions
+    }
+
+    if (insufficientDataActions && insufficientDataActions.length > 0) {
+      alarm.Properties!.InsufficientDataActions = insufficientDataActions
+    }
+
+    return { alarm, logicalId }
+  }
+
+  /**
+   * Create a CloudWatch dashboard
+   */
+  static createDashboard(options: DashboardOptions): {
+    dashboard: CloudWatchDashboard
+    logicalId: string
+  } {
+    const {
+      slug,
+      environment,
+      dashboardName,
+      widgets,
+    } = options
+
+    const resourceName = dashboardName || generateResourceName({
+      slug,
+      environment,
+      resourceType: 'dashboard',
+    })
+
+    const logicalId = generateLogicalId(resourceName)
+
+    const dashboardBody = {
+      widgets: widgets.map(widget => ({
+        type: widget.type,
+        x: widget.x,
+        y: widget.y,
+        width: widget.width,
+        height: widget.height,
+        properties: widget.properties,
+      })),
+    }
+
+    const dashboard: CloudWatchDashboard = {
+      Type: 'AWS::CloudWatch::Dashboard',
+      Properties: {
+        DashboardName: resourceName,
+        DashboardBody: JSON.stringify(dashboardBody),
+      },
+    }
+
+    return { dashboard, logicalId }
+  }
+
+  /**
+   * Create a CloudWatch log group
+   */
+  static createLogGroup(options: LogGroupOptions): {
+    logGroup: CloudWatchLogGroup
+    logicalId: string
+  } {
+    const {
+      slug,
+      environment,
+      logGroupName,
+      retentionInDays,
+      kmsKeyId,
+    } = options
+
+    const resourceName = logGroupName || generateResourceName({
+      slug,
+      environment,
+      resourceType: 'log-group',
+    })
+
+    const logicalId = generateLogicalId(resourceName)
+
+    const logGroup: CloudWatchLogGroup = {
+      Type: 'AWS::Logs::LogGroup',
+      Properties: {
+        LogGroupName: resourceName,
+      },
+    }
+
+    if (retentionInDays !== undefined) {
+      logGroup.Properties!.RetentionInDays = retentionInDays as 1 | 3 | 5 | 7 | 14 | 30 | 60 | 90 | 120 | 150 | 180 | 365 | 400 | 545 | 731 | 1827 | 3653
+    }
+
+    if (kmsKeyId) {
+      logGroup.Properties!.KmsKeyId = kmsKeyId
+    }
+
+    return { logGroup, logicalId }
+  }
+
+  /**
+   * Create a CloudWatch log stream
+   */
+  static createLogStream(
+    logGroupLogicalId: string,
+    options: LogStreamOptions,
+  ): {
+      logStream: CloudWatchLogStream
+      logicalId: string
+    } {
+    const {
+      slug,
+      environment,
+      logStreamName,
+    } = options
+
+    const resourceName = logStreamName || generateResourceName({
+      slug,
+      environment,
+      resourceType: 'log-stream',
+    })
+
+    const logicalId = generateLogicalId(resourceName)
+
+    const logStream: CloudWatchLogStream = {
+      Type: 'AWS::Logs::LogStream',
+      Properties: {
+        LogGroupName: Fn.Ref(logGroupLogicalId) as unknown as string,
+        LogStreamName: resourceName,
+      },
+    }
+
+    return { logStream, logicalId }
+  }
+
+  /**
+   * Create a metric filter for log group
+   */
+  static createMetricFilter(
+    logGroupLogicalId: string,
+    options: MetricFilterOptions,
+  ): {
+      metricFilter: CloudWatchMetricFilter
+      logicalId: string
+    } {
+    const {
+      slug,
+      environment,
+      filterName,
+      filterPattern,
+      metricTransformations,
+    } = options
+
+    const resourceName = filterName || generateResourceName({
+      slug,
+      environment,
+      resourceType: 'metric-filter',
+    })
+
+    const logicalId = generateLogicalId(resourceName)
+
+    const metricFilter: CloudWatchMetricFilter = {
+      Type: 'AWS::Logs::MetricFilter',
+      Properties: {
+        LogGroupName: Fn.Ref(logGroupLogicalId) as unknown as string,
+        FilterPattern: filterPattern,
+        MetricTransformations: metricTransformations.map(t => ({
+          MetricName: t.metricName,
+          MetricNamespace: t.metricNamespace,
+          MetricValue: t.metricValue,
+          DefaultValue: t.defaultValue,
+          Unit: t.unit,
+        })),
+      },
+    }
+
+    return { metricFilter, logicalId }
+  }
+
+  /**
+   * Common alarm configurations
+   */
+  static readonly AlarmTypes = {
+    /**
+     * High CPU utilization alarm
+     */
+    highCpu: (
+      slug: string,
+      environment: EnvironmentType,
+      resourceId: string,
+      threshold: number = 80,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-high-cpu`,
+      metricName: 'CPUUtilization',
+      namespace: 'AWS/EC2',
+      statistic: 'Average',
+      period: 300,
+      evaluationPeriods: 2,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { InstanceId: resourceId },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * High memory utilization alarm
+     */
+    highMemory: (
+      slug: string,
+      environment: EnvironmentType,
+      resourceId: string,
+      threshold: number = 80,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-high-memory`,
+      metricName: 'MemoryUtilization',
+      namespace: 'System/Linux',
+      statistic: 'Average',
+      period: 300,
+      evaluationPeriods: 2,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { InstanceId: resourceId },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * High disk utilization alarm
+     */
+    highDisk: (
+      slug: string,
+      environment: EnvironmentType,
+      resourceId: string,
+      threshold: number = 80,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-high-disk`,
+      metricName: 'DiskSpaceUtilization',
+      namespace: 'System/Linux',
+      statistic: 'Average',
+      period: 300,
+      evaluationPeriods: 2,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { InstanceId: resourceId, Filesystem: '/dev/xvda1', MountPath: '/' },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * Lambda error rate alarm
+     */
+    lambdaErrors: (
+      slug: string,
+      environment: EnvironmentType,
+      functionName: string,
+      threshold: number = 5,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-lambda-errors`,
+      metricName: 'Errors',
+      namespace: 'AWS/Lambda',
+      statistic: 'Sum',
+      period: 300,
+      evaluationPeriods: 1,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { FunctionName: functionName },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * Lambda throttles alarm
+     */
+    lambdaThrottles: (
+      slug: string,
+      environment: EnvironmentType,
+      functionName: string,
+      threshold: number = 10,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-lambda-throttles`,
+      metricName: 'Throttles',
+      namespace: 'AWS/Lambda',
+      statistic: 'Sum',
+      period: 300,
+      evaluationPeriods: 1,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { FunctionName: functionName },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * API Gateway 5xx errors alarm
+     */
+    apiGateway5xxErrors: (
+      slug: string,
+      environment: EnvironmentType,
+      apiName: string,
+      threshold: number = 10,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-api-5xx-errors`,
+      metricName: '5XXError',
+      namespace: 'AWS/ApiGateway',
+      statistic: 'Sum',
+      period: 300,
+      evaluationPeriods: 1,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { ApiName: apiName },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * API Gateway 4xx errors alarm
+     */
+    apiGateway4xxErrors: (
+      slug: string,
+      environment: EnvironmentType,
+      apiName: string,
+      threshold: number = 50,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-api-4xx-errors`,
+      metricName: '4XXError',
+      namespace: 'AWS/ApiGateway',
+      statistic: 'Sum',
+      period: 300,
+      evaluationPeriods: 2,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { ApiName: apiName },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * DynamoDB throttled requests alarm
+     */
+    dynamoDBThrottles: (
+      slug: string,
+      environment: EnvironmentType,
+      tableName: string,
+      threshold: number = 5,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-dynamodb-throttles`,
+      metricName: 'UserErrors',
+      namespace: 'AWS/DynamoDB',
+      statistic: 'Sum',
+      period: 300,
+      evaluationPeriods: 1,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { TableName: tableName },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * RDS CPU alarm
+     */
+    rdsCpu: (
+      slug: string,
+      environment: EnvironmentType,
+      dbInstanceId: string,
+      threshold: number = 80,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-rds-cpu`,
+      metricName: 'CPUUtilization',
+      namespace: 'AWS/RDS',
+      statistic: 'Average',
+      period: 300,
+      evaluationPeriods: 2,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { DBInstanceIdentifier: dbInstanceId },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * RDS free storage alarm
+     */
+    rdsFreeStorage: (
+      slug: string,
+      environment: EnvironmentType,
+      dbInstanceId: string,
+      threshold: number = 5368709120, // 5GB in bytes
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-rds-storage`,
+      metricName: 'FreeStorageSpace',
+      namespace: 'AWS/RDS',
+      statistic: 'Average',
+      period: 300,
+      evaluationPeriods: 1,
+      threshold,
+      comparisonOperator: 'LessThanThreshold',
+      dimensions: { DBInstanceIdentifier: dbInstanceId },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+      unit: 'Bytes',
+    }),
+
+    /**
+     * SQS queue depth alarm
+     */
+    sqsQueueDepth: (
+      slug: string,
+      environment: EnvironmentType,
+      queueName: string,
+      threshold: number = 100,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-sqs-depth`,
+      metricName: 'ApproximateNumberOfMessagesVisible',
+      namespace: 'AWS/SQS',
+      statistic: 'Average',
+      period: 300,
+      evaluationPeriods: 2,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { QueueName: queueName },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * ALB target unhealthy alarm
+     */
+    albUnhealthyTargets: (
+      slug: string,
+      environment: EnvironmentType,
+      loadBalancer: string,
+      targetGroup: string,
+      threshold: number = 1,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-alb-unhealthy`,
+      metricName: 'UnHealthyHostCount',
+      namespace: 'AWS/ApplicationELB',
+      statistic: 'Average',
+      period: 300,
+      evaluationPeriods: 2,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { LoadBalancer: loadBalancer, TargetGroup: targetGroup },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * SES bounce rate alarm
+     */
+    sesBounceRate: (
+      slug: string,
+      environment: EnvironmentType,
+      threshold: number = 5,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-ses-bounce-rate`,
+      metricName: 'Reputation.BounceRate',
+      namespace: 'AWS/SES',
+      statistic: 'Average',
+      period: 3600,
+      evaluationPeriods: 1,
+      threshold: threshold / 100, // Convert percentage to decimal
+      comparisonOperator: 'GreaterThanThreshold',
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * SES complaint rate alarm
+     */
+    sesComplaintRate: (
+      slug: string,
+      environment: EnvironmentType,
+      threshold: number = 0.1,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-ses-complaint-rate`,
+      metricName: 'Reputation.ComplaintRate',
+      namespace: 'AWS/SES',
+      statistic: 'Average',
+      period: 3600,
+      evaluationPeriods: 1,
+      threshold: threshold / 100,
+      comparisonOperator: 'GreaterThanThreshold',
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * Pinpoint SMS delivery failure alarm
+     */
+    smsDeliveryFailure: (
+      slug: string,
+      environment: EnvironmentType,
+      applicationId: string,
+      threshold: number = 10,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-sms-delivery-failure`,
+      metricName: 'DirectSendMessagePermanentFailure',
+      namespace: 'AWS/Pinpoint',
+      statistic: 'Sum',
+      period: 300,
+      evaluationPeriods: 1,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { ApplicationId: applicationId },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * Pinpoint SMS spend alarm
+     */
+    smsSpendLimit: (
+      slug: string,
+      environment: EnvironmentType,
+      threshold: number = 100,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-sms-spend-limit`,
+      metricName: 'DirectSendMessageSpend',
+      namespace: 'AWS/Pinpoint',
+      statistic: 'Sum',
+      period: 86400, // Daily
+      evaluationPeriods: 1,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+
+    /**
+     * Connect missed calls alarm
+     */
+    connectMissedCalls: (
+      slug: string,
+      environment: EnvironmentType,
+      instanceId: string,
+      threshold: number = 5,
+      snsTopicArn?: string,
+    ): AlarmOptions => ({
+      slug,
+      environment,
+      alarmName: `${slug}-${environment}-connect-missed-calls`,
+      metricName: 'MissedCalls',
+      namespace: 'AWS/Connect',
+      statistic: 'Sum',
+      period: 3600,
+      evaluationPeriods: 1,
+      threshold,
+      comparisonOperator: 'GreaterThanThreshold',
+      dimensions: { InstanceId: instanceId },
+      alarmActions: snsTopicArn ? [snsTopicArn] : undefined,
+    }),
+  } as const
+
+  /**
+   * Common dashboard widgets
+   */
+  static readonly DashboardWidgets = {
+    /**
+     * Metric widget
+     */
+    metric: (
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      metrics: Array<[string, string, Record<string, string>?]>,
+      title?: string,
+    ): DashboardWidget => ({
+      type: 'metric',
+      x,
+      y,
+      width,
+      height,
+      properties: {
+        metrics,
+        title: title || 'Metrics',
+        region: 'us-east-1',
+        period: 300,
+      },
+    }),
+
+    /**
+     * Text widget
+     */
+    text: (
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      markdown: string,
+    ): DashboardWidget => ({
+      type: 'text',
+      x,
+      y,
+      width,
+      height,
+      properties: {
+        markdown,
+      },
+    }),
+
+    /**
+     * Log widget
+     */
+    log: (
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      logGroupNames: string[],
+      title?: string,
+    ): DashboardWidget => ({
+      type: 'log',
+      x,
+      y,
+      width,
+      height,
+      properties: {
+        query: `SOURCE '${logGroupNames.join("' | SOURCE '")}'
+| fields @timestamp, @message
+| sort @timestamp desc
+| limit 20`,
+        region: 'us-east-1',
+        title: title || 'Logs',
+      },
+    }),
+  } as const
+
+  /**
+   * Common log retention periods
+   */
+  static readonly RetentionPeriods = {
+    ONE_DAY: 1,
+    THREE_DAYS: 3,
+    FIVE_DAYS: 5,
+    ONE_WEEK: 7,
+    TWO_WEEKS: 14,
+    ONE_MONTH: 30,
+    TWO_MONTHS: 60,
+    THREE_MONTHS: 90,
+    FOUR_MONTHS: 120,
+    FIVE_MONTHS: 150,
+    SIX_MONTHS: 180,
+    ONE_YEAR: 365,
+    THIRTEEN_MONTHS: 400,
+    EIGHTEEN_MONTHS: 545,
+    TWO_YEARS: 731,
+    FIVE_YEARS: 1827,
+    TEN_YEARS: 3653,
+    NEVER_EXPIRE: undefined,
+  } as const
+
+  /**
+   * Common metric filter patterns
+   */
+  static readonly FilterPatterns = {
+    /**
+     * Match ERROR log lines
+     */
+    errors: '[time, request_id, event_type = ERROR*, ...]',
+
+    /**
+     * Match all log lines
+     */
+    all: '',
+
+    /**
+     * Match JSON logs with specific field
+     */
+    jsonField: (field: string, value: string): string => `{ $.${field} = "${value}" }`,
+
+    /**
+     * Match HTTP status codes
+     */
+    httpStatus: (statusCode: number): string => `[..., status_code = ${statusCode}, ...]`,
+
+    /**
+     * Match 4xx errors
+     */
+    http4xx: '[..., status_code = 4*, ...]',
+
+    /**
+     * Match 5xx errors
+     */
+    http5xx: '[..., status_code = 5*, ...]',
+  } as const
+
+  /**
+   * Create a comprehensive application dashboard
+   */
+  static createApplicationDashboard(options: {
+    slug: string
+    environment: EnvironmentType
+    region?: string
+    components?: {
+      ec2InstanceIds?: string[]
+      lambdaFunctionNames?: string[]
+      ecsClusterName?: string
+      ecsServiceName?: string
+      albName?: string
+      targetGroupName?: string
+      rdsInstanceId?: string
+      sqsQueueNames?: string[]
+      logGroupNames?: string[]
+    }
+  }): {
+    dashboard: CloudWatchDashboard
+    logicalId: string
+  } {
+    const {
+      slug,
+      environment,
+      region = 'us-east-1',
+      components = {},
+    } = options
+
+    const widgets: DashboardWidget[] = []
+    let currentY = 0
+
+    // Header text widget
+    widgets.push({
+      type: 'text',
+      x: 0,
+      y: currentY,
+      width: 24,
+      height: 1,
+      properties: {
+        markdown: `# ${slug.toUpperCase()} Dashboard (${environment})`,
+      },
+    })
+    currentY += 1
+
+    // EC2 metrics
+    if (components.ec2InstanceIds && components.ec2InstanceIds.length > 0) {
+      widgets.push({
+        type: 'text',
+        x: 0,
+        y: currentY,
+        width: 24,
+        height: 1,
+        properties: {
+          markdown: '## EC2 Instances',
+        },
+      })
+      currentY += 1
+
+      // CPU utilization
+      widgets.push({
+        type: 'metric',
+        x: 0,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'CPU Utilization',
+          region,
+          metrics: components.ec2InstanceIds.map(id => [
+            'AWS/EC2',
+            'CPUUtilization',
+            'InstanceId',
+            id,
+          ]),
+          period: 300,
+          stat: 'Average',
+        },
+      })
+
+      // Network In/Out
+      widgets.push({
+        type: 'metric',
+        x: 8,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Network Traffic',
+          region,
+          metrics: [
+            ...components.ec2InstanceIds.flatMap(id => [
+              ['AWS/EC2', 'NetworkIn', 'InstanceId', id, { label: `${id} In` }],
+              ['AWS/EC2', 'NetworkOut', 'InstanceId', id, { label: `${id} Out` }],
+            ]),
+          ],
+          period: 300,
+          stat: 'Sum',
+        },
+      })
+
+      // Status check
+      widgets.push({
+        type: 'metric',
+        x: 16,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Status Checks',
+          region,
+          metrics: components.ec2InstanceIds.map(id => [
+            'AWS/EC2',
+            'StatusCheckFailed',
+            'InstanceId',
+            id,
+          ]),
+          period: 60,
+          stat: 'Maximum',
+        },
+      })
+
+      currentY += 6
+    }
+
+    // Lambda metrics
+    if (components.lambdaFunctionNames && components.lambdaFunctionNames.length > 0) {
+      widgets.push({
+        type: 'text',
+        x: 0,
+        y: currentY,
+        width: 24,
+        height: 1,
+        properties: {
+          markdown: '## Lambda Functions',
+        },
+      })
+      currentY += 1
+
+      // Invocations
+      widgets.push({
+        type: 'metric',
+        x: 0,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Invocations',
+          region,
+          metrics: components.lambdaFunctionNames.map(name => [
+            'AWS/Lambda',
+            'Invocations',
+            'FunctionName',
+            name,
+          ]),
+          period: 300,
+          stat: 'Sum',
+        },
+      })
+
+      // Duration
+      widgets.push({
+        type: 'metric',
+        x: 8,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Duration',
+          region,
+          metrics: components.lambdaFunctionNames.map(name => [
+            'AWS/Lambda',
+            'Duration',
+            'FunctionName',
+            name,
+          ]),
+          period: 300,
+          stat: 'Average',
+        },
+      })
+
+      // Errors
+      widgets.push({
+        type: 'metric',
+        x: 16,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Errors',
+          region,
+          metrics: components.lambdaFunctionNames.map(name => [
+            'AWS/Lambda',
+            'Errors',
+            'FunctionName',
+            name,
+          ]),
+          period: 300,
+          stat: 'Sum',
+        },
+      })
+
+      currentY += 6
+    }
+
+    // ECS metrics
+    if (components.ecsClusterName && components.ecsServiceName) {
+      widgets.push({
+        type: 'text',
+        x: 0,
+        y: currentY,
+        width: 24,
+        height: 1,
+        properties: {
+          markdown: '## ECS Service',
+        },
+      })
+      currentY += 1
+
+      // CPU utilization
+      widgets.push({
+        type: 'metric',
+        x: 0,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'CPU Utilization',
+          region,
+          metrics: [
+            ['AWS/ECS', 'CPUUtilization', 'ClusterName', components.ecsClusterName, 'ServiceName', components.ecsServiceName],
+          ],
+          period: 300,
+          stat: 'Average',
+        },
+      })
+
+      // Memory utilization
+      widgets.push({
+        type: 'metric',
+        x: 8,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Memory Utilization',
+          region,
+          metrics: [
+            ['AWS/ECS', 'MemoryUtilization', 'ClusterName', components.ecsClusterName, 'ServiceName', components.ecsServiceName],
+          ],
+          period: 300,
+          stat: 'Average',
+        },
+      })
+
+      // Running tasks
+      widgets.push({
+        type: 'metric',
+        x: 16,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Running Tasks',
+          region,
+          metrics: [
+            ['ECS/ContainerInsights', 'RunningTaskCount', 'ClusterName', components.ecsClusterName, 'ServiceName', components.ecsServiceName],
+          ],
+          period: 60,
+          stat: 'Average',
+        },
+      })
+
+      currentY += 6
+    }
+
+    // ALB metrics
+    if (components.albName) {
+      widgets.push({
+        type: 'text',
+        x: 0,
+        y: currentY,
+        width: 24,
+        height: 1,
+        properties: {
+          markdown: '## Application Load Balancer',
+        },
+      })
+      currentY += 1
+
+      // Request count
+      widgets.push({
+        type: 'metric',
+        x: 0,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Request Count',
+          region,
+          metrics: [
+            ['AWS/ApplicationELB', 'RequestCount', 'LoadBalancer', components.albName],
+          ],
+          period: 60,
+          stat: 'Sum',
+        },
+      })
+
+      // Response time
+      widgets.push({
+        type: 'metric',
+        x: 8,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Response Time',
+          region,
+          metrics: [
+            ['AWS/ApplicationELB', 'TargetResponseTime', 'LoadBalancer', components.albName],
+          ],
+          period: 60,
+          stat: 'Average',
+        },
+      })
+
+      // HTTP errors
+      widgets.push({
+        type: 'metric',
+        x: 16,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'HTTP Errors',
+          region,
+          metrics: [
+            ['AWS/ApplicationELB', 'HTTPCode_Target_4XX_Count', 'LoadBalancer', components.albName, { label: '4XX' }],
+            ['AWS/ApplicationELB', 'HTTPCode_Target_5XX_Count', 'LoadBalancer', components.albName, { label: '5XX' }],
+          ],
+          period: 60,
+          stat: 'Sum',
+        },
+      })
+
+      currentY += 6
+    }
+
+    // RDS metrics
+    if (components.rdsInstanceId) {
+      widgets.push({
+        type: 'text',
+        x: 0,
+        y: currentY,
+        width: 24,
+        height: 1,
+        properties: {
+          markdown: '## RDS Database',
+        },
+      })
+      currentY += 1
+
+      // CPU
+      widgets.push({
+        type: 'metric',
+        x: 0,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'CPU Utilization',
+          region,
+          metrics: [
+            ['AWS/RDS', 'CPUUtilization', 'DBInstanceIdentifier', components.rdsInstanceId],
+          ],
+          period: 300,
+          stat: 'Average',
+        },
+      })
+
+      // Connections
+      widgets.push({
+        type: 'metric',
+        x: 8,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Database Connections',
+          region,
+          metrics: [
+            ['AWS/RDS', 'DatabaseConnections', 'DBInstanceIdentifier', components.rdsInstanceId],
+          ],
+          period: 60,
+          stat: 'Sum',
+        },
+      })
+
+      // Free storage
+      widgets.push({
+        type: 'metric',
+        x: 16,
+        y: currentY,
+        width: 8,
+        height: 6,
+        properties: {
+          title: 'Free Storage Space',
+          region,
+          metrics: [
+            ['AWS/RDS', 'FreeStorageSpace', 'DBInstanceIdentifier', components.rdsInstanceId],
+          ],
+          period: 300,
+          stat: 'Average',
+        },
+      })
+
+      currentY += 6
+    }
+
+    // SQS metrics
+    if (components.sqsQueueNames && components.sqsQueueNames.length > 0) {
+      widgets.push({
+        type: 'text',
+        x: 0,
+        y: currentY,
+        width: 24,
+        height: 1,
+        properties: {
+          markdown: '## SQS Queues',
+        },
+      })
+      currentY += 1
+
+      // Messages visible
+      widgets.push({
+        type: 'metric',
+        x: 0,
+        y: currentY,
+        width: 12,
+        height: 6,
+        properties: {
+          title: 'Messages Visible',
+          region,
+          metrics: components.sqsQueueNames.map(name => [
+            'AWS/SQS',
+            'ApproximateNumberOfMessagesVisible',
+            'QueueName',
+            name,
+          ]),
+          period: 60,
+          stat: 'Sum',
+        },
+      })
+
+      // Age of oldest message
+      widgets.push({
+        type: 'metric',
+        x: 12,
+        y: currentY,
+        width: 12,
+        height: 6,
+        properties: {
+          title: 'Message Age',
+          region,
+          metrics: components.sqsQueueNames.map(name => [
+            'AWS/SQS',
+            'ApproximateAgeOfOldestMessage',
+            'QueueName',
+            name,
+          ]),
+          period: 60,
+          stat: 'Maximum',
+        },
+      })
+
+      currentY += 6
+    }
+
+    // Log widget
+    if (components.logGroupNames && components.logGroupNames.length > 0) {
+      widgets.push({
+        type: 'text',
+        x: 0,
+        y: currentY,
+        width: 24,
+        height: 1,
+        properties: {
+          markdown: '## Application Logs',
+        },
+      })
+      currentY += 1
+
+      widgets.push({
+        type: 'log',
+        x: 0,
+        y: currentY,
+        width: 24,
+        height: 6,
+        properties: {
+          query: `SOURCE '${components.logGroupNames.join("' | SOURCE '")}'
+| fields @timestamp, @message
+| filter @message like /ERROR|WARN|Exception/
+| sort @timestamp desc
+| limit 50`,
+          region,
+          title: 'Recent Errors and Warnings',
+        },
+      })
+
+      currentY += 6
+    }
+
+    return Monitoring.createDashboard({
+      slug,
+      environment,
+      widgets,
+    })
+  }
+
+  /**
+   * Dashboard templates for common architectures
+   */
+  static readonly DashboardTemplates = {
+    /**
+     * Static website dashboard (S3 + CloudFront)
+     */
+    staticWebsite: (options: {
+      slug: string
+      environment: EnvironmentType
+      region?: string
+      cloudFrontDistributionId: string
+      s3BucketName: string
+    }): DashboardOptions => ({
+      slug: options.slug,
+      environment: options.environment,
+      widgets: [
+        {
+          type: 'text',
+          x: 0,
+          y: 0,
+          width: 24,
+          height: 1,
+          properties: {
+            markdown: `# ${options.slug.toUpperCase()} Static Website Dashboard`,
+          },
+        },
+        {
+          type: 'metric',
+          x: 0,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'CloudFront Requests',
+            region: 'us-east-1',
+            metrics: [
+              ['AWS/CloudFront', 'Requests', 'DistributionId', options.cloudFrontDistributionId, 'Region', 'Global'],
+            ],
+            period: 300,
+            stat: 'Sum',
+          },
+        },
+        {
+          type: 'metric',
+          x: 8,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'Error Rate',
+            region: 'us-east-1',
+            metrics: [
+              ['AWS/CloudFront', '4xxErrorRate', 'DistributionId', options.cloudFrontDistributionId, 'Region', 'Global', { label: '4XX' }],
+              ['AWS/CloudFront', '5xxErrorRate', 'DistributionId', options.cloudFrontDistributionId, 'Region', 'Global', { label: '5XX' }],
+            ],
+            period: 300,
+            stat: 'Average',
+          },
+        },
+        {
+          type: 'metric',
+          x: 16,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'Bytes Downloaded',
+            region: 'us-east-1',
+            metrics: [
+              ['AWS/CloudFront', 'BytesDownloaded', 'DistributionId', options.cloudFrontDistributionId, 'Region', 'Global'],
+            ],
+            period: 300,
+            stat: 'Sum',
+          },
+        },
+        {
+          type: 'metric',
+          x: 0,
+          y: 7,
+          width: 12,
+          height: 6,
+          properties: {
+            title: 'S3 Bucket Size',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/S3', 'BucketSizeBytes', 'BucketName', options.s3BucketName, 'StorageType', 'StandardStorage'],
+            ],
+            period: 86400,
+            stat: 'Average',
+          },
+        },
+        {
+          type: 'metric',
+          x: 12,
+          y: 7,
+          width: 12,
+          height: 6,
+          properties: {
+            title: 'S3 Number of Objects',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/S3', 'NumberOfObjects', 'BucketName', options.s3BucketName, 'StorageType', 'AllStorageTypes'],
+            ],
+            period: 86400,
+            stat: 'Average',
+          },
+        },
+      ],
+    }),
+
+    /**
+     * Serverless API dashboard (Lambda + API Gateway)
+     */
+    serverlessApi: (options: {
+      slug: string
+      environment: EnvironmentType
+      region?: string
+      apiGatewayName: string
+      lambdaFunctionNames: string[]
+    }): DashboardOptions => ({
+      slug: options.slug,
+      environment: options.environment,
+      widgets: [
+        {
+          type: 'text',
+          x: 0,
+          y: 0,
+          width: 24,
+          height: 1,
+          properties: {
+            markdown: `# ${options.slug.toUpperCase()} Serverless API Dashboard`,
+          },
+        },
+        {
+          type: 'metric',
+          x: 0,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'API Requests',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/ApiGateway', 'Count', 'ApiName', options.apiGatewayName],
+            ],
+            period: 60,
+            stat: 'Sum',
+          },
+        },
+        {
+          type: 'metric',
+          x: 8,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'API Latency',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/ApiGateway', 'Latency', 'ApiName', options.apiGatewayName],
+            ],
+            period: 60,
+            stat: 'Average',
+          },
+        },
+        {
+          type: 'metric',
+          x: 16,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'API Errors',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/ApiGateway', '4XXError', 'ApiName', options.apiGatewayName, { label: '4XX' }],
+              ['AWS/ApiGateway', '5XXError', 'ApiName', options.apiGatewayName, { label: '5XX' }],
+            ],
+            period: 60,
+            stat: 'Sum',
+          },
+        },
+        ...options.lambdaFunctionNames.map((name, index) => ({
+          type: 'metric' as const,
+          x: (index % 3) * 8,
+          y: 7 + Math.floor(index / 3) * 6,
+          width: 8,
+          height: 6,
+          properties: {
+            title: `${name} Metrics`,
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/Lambda', 'Invocations', 'FunctionName', name],
+              ['AWS/Lambda', 'Duration', 'FunctionName', name],
+              ['AWS/Lambda', 'Errors', 'FunctionName', name],
+            ],
+            period: 300,
+            stat: 'Sum',
+          },
+        })),
+      ],
+    }),
+
+    /**
+     * Container service dashboard (ECS + ALB)
+     */
+    containerService: (options: {
+      slug: string
+      environment: EnvironmentType
+      region?: string
+      ecsClusterName: string
+      ecsServiceName: string
+      albName: string
+      rdsInstanceId?: string
+    }): DashboardOptions => ({
+      slug: options.slug,
+      environment: options.environment,
+      widgets: [
+        {
+          type: 'text',
+          x: 0,
+          y: 0,
+          width: 24,
+          height: 1,
+          properties: {
+            markdown: `# ${options.slug.toUpperCase()} Container Service Dashboard`,
+          },
+        },
+        // ECS metrics
+        {
+          type: 'metric',
+          x: 0,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'ECS CPU',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/ECS', 'CPUUtilization', 'ClusterName', options.ecsClusterName, 'ServiceName', options.ecsServiceName],
+            ],
+            period: 60,
+            stat: 'Average',
+          },
+        },
+        {
+          type: 'metric',
+          x: 8,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'ECS Memory',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/ECS', 'MemoryUtilization', 'ClusterName', options.ecsClusterName, 'ServiceName', options.ecsServiceName],
+            ],
+            period: 60,
+            stat: 'Average',
+          },
+        },
+        {
+          type: 'metric',
+          x: 16,
+          y: 1,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'Running Tasks',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['ECS/ContainerInsights', 'RunningTaskCount', 'ClusterName', options.ecsClusterName, 'ServiceName', options.ecsServiceName],
+            ],
+            period: 60,
+            stat: 'Average',
+          },
+        },
+        // ALB metrics
+        {
+          type: 'metric',
+          x: 0,
+          y: 7,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'ALB Requests',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/ApplicationELB', 'RequestCount', 'LoadBalancer', options.albName],
+            ],
+            period: 60,
+            stat: 'Sum',
+          },
+        },
+        {
+          type: 'metric',
+          x: 8,
+          y: 7,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'Response Time',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/ApplicationELB', 'TargetResponseTime', 'LoadBalancer', options.albName],
+            ],
+            period: 60,
+            stat: 'Average',
+          },
+        },
+        {
+          type: 'metric',
+          x: 16,
+          y: 7,
+          width: 8,
+          height: 6,
+          properties: {
+            title: 'Healthy Hosts',
+            region: options.region || 'us-east-1',
+            metrics: [
+              ['AWS/ApplicationELB', 'HealthyHostCount', 'LoadBalancer', options.albName],
+            ],
+            period: 60,
+            stat: 'Average',
+          },
+        },
+        ...(options.rdsInstanceId
+          ? [
+              {
+                type: 'metric' as const,
+                x: 0,
+                y: 13,
+                width: 12,
+                height: 6,
+                properties: {
+                  title: 'RDS CPU',
+                  region: options.region || 'us-east-1',
+                  metrics: [
+                    ['AWS/RDS', 'CPUUtilization', 'DBInstanceIdentifier', options.rdsInstanceId],
+                  ],
+                  period: 300,
+                  stat: 'Average',
+                },
+              },
+              {
+                type: 'metric' as const,
+                x: 12,
+                y: 13,
+                width: 12,
+                height: 6,
+                properties: {
+                  title: 'RDS Connections',
+                  region: options.region || 'us-east-1',
+                  metrics: [
+                    ['AWS/RDS', 'DatabaseConnections', 'DBInstanceIdentifier', options.rdsInstanceId],
+                  ],
+                  period: 60,
+                  stat: 'Sum',
+                },
+              },
+            ]
+          : []),
+      ],
+    }),
+  }
+
+  /**
+   * Monitoring Configuration helpers
+   * Provides Stacks configuration parity for monitoring options
+   */
+  static readonly Config = {
+    /**
+     * Create alarm configuration
+     */
+    createAlarmConfig: (options: {
+      metricName: string
+      namespace: string
+      threshold: number
+      comparisonOperator?: 'GreaterThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanThreshold' | 'LessThanOrEqualToThreshold'
+      evaluationPeriods?: number
+      period?: number
+      statistic?: 'Average' | 'Sum' | 'Maximum' | 'Minimum' | 'SampleCount'
+      treatMissingData?: 'breaching' | 'notBreaching' | 'ignore' | 'missing'
+    }): {
+      MetricName: string
+      Namespace: string
+      Threshold: number
+      ComparisonOperator: string
+      EvaluationPeriods: number
+      Period: number
+      Statistic: string
+      TreatMissingData: string
+    } => {
+      const {
+        metricName,
+        namespace,
+        threshold,
+        comparisonOperator = 'GreaterThanThreshold',
+        evaluationPeriods = 1,
+        period = 300,
+        statistic = 'Average',
+        treatMissingData = 'missing',
+      } = options
+
+      return {
+        MetricName: metricName,
+        Namespace: namespace,
+        Threshold: threshold,
+        ComparisonOperator: comparisonOperator,
+        EvaluationPeriods: evaluationPeriods,
+        Period: period,
+        Statistic: statistic,
+        TreatMissingData: treatMissingData,
+      }
+    },
+
+    /**
+     * AWS namespace constants
+     */
+    namespaces: {
+      ec2: 'AWS/EC2',
+      ecs: 'AWS/ECS',
+      lambda: 'AWS/Lambda',
+      rds: 'AWS/RDS',
+      sqs: 'AWS/SQS',
+      sns: 'AWS/SNS',
+      s3: 'AWS/S3',
+      cloudfront: 'AWS/CloudFront',
+      alb: 'AWS/ApplicationELB',
+      nlb: 'AWS/NetworkELB',
+      apiGateway: 'AWS/ApiGateway',
+      dynamodb: 'AWS/DynamoDB',
+      elasticache: 'AWS/ElastiCache',
+    } as const,
+
+    /**
+     * Comparison operator options
+     */
+    comparisonOperators: {
+      greaterThan: 'GreaterThanThreshold',
+      greaterOrEqual: 'GreaterThanOrEqualToThreshold',
+      lessThan: 'LessThanThreshold',
+      lessOrEqual: 'LessThanOrEqualToThreshold',
+    } as const,
+
+    /**
+     * Common metric configurations by service
+     */
+    metrics: {
+      ec2: {
+        cpu: { metricName: 'CPUUtilization', namespace: 'AWS/EC2' },
+        networkIn: { metricName: 'NetworkIn', namespace: 'AWS/EC2' },
+        networkOut: { metricName: 'NetworkOut', namespace: 'AWS/EC2' },
+        statusCheck: { metricName: 'StatusCheckFailed', namespace: 'AWS/EC2' },
+      },
+      ecs: {
+        cpu: { metricName: 'CPUUtilization', namespace: 'AWS/ECS' },
+        memory: { metricName: 'MemoryUtilization', namespace: 'AWS/ECS' },
+      },
+      lambda: {
+        invocations: { metricName: 'Invocations', namespace: 'AWS/Lambda' },
+        errors: { metricName: 'Errors', namespace: 'AWS/Lambda' },
+        duration: { metricName: 'Duration', namespace: 'AWS/Lambda' },
+        throttles: { metricName: 'Throttles', namespace: 'AWS/Lambda' },
+        concurrentExecutions: { metricName: 'ConcurrentExecutions', namespace: 'AWS/Lambda' },
+      },
+      rds: {
+        cpu: { metricName: 'CPUUtilization', namespace: 'AWS/RDS' },
+        connections: { metricName: 'DatabaseConnections', namespace: 'AWS/RDS' },
+        freeStorage: { metricName: 'FreeStorageSpace', namespace: 'AWS/RDS' },
+        readLatency: { metricName: 'ReadLatency', namespace: 'AWS/RDS' },
+        writeLatency: { metricName: 'WriteLatency', namespace: 'AWS/RDS' },
+      },
+      alb: {
+        requestCount: { metricName: 'RequestCount', namespace: 'AWS/ApplicationELB' },
+        responseTime: { metricName: 'TargetResponseTime', namespace: 'AWS/ApplicationELB' },
+        httpCode4xx: { metricName: 'HTTPCode_Target_4XX_Count', namespace: 'AWS/ApplicationELB' },
+        httpCode5xx: { metricName: 'HTTPCode_Target_5XX_Count', namespace: 'AWS/ApplicationELB' },
+        healthyHosts: { metricName: 'HealthyHostCount', namespace: 'AWS/ApplicationELB' },
+      },
+      sqs: {
+        messagesVisible: { metricName: 'ApproximateNumberOfMessagesVisible', namespace: 'AWS/SQS' },
+        messagesDelayed: { metricName: 'ApproximateNumberOfMessagesDelayed', namespace: 'AWS/SQS' },
+        messageAge: { metricName: 'ApproximateAgeOfOldestMessage', namespace: 'AWS/SQS' },
+      },
+    },
+
+    /**
+     * Common alarm presets
+     */
+    presets: {
+      /**
+       * High CPU alarm
+       */
+      highCpu: (threshold: number = 80): {
+        metricName: string;
+        threshold: number;
+        comparisonOperator: 'GreaterThanThreshold';
+        evaluationPeriods: number;
+        period: number;
+        statistic: 'Average';
+      } => ({
+        metricName: 'CPUUtilization',
+        threshold,
+        comparisonOperator: 'GreaterThanThreshold' as const,
+        evaluationPeriods: 3,
+        period: 300,
+        statistic: 'Average' as const,
+      }),
+
+      /**
+       * High memory alarm (for ECS)
+       */
+      highMemory: (threshold: number = 80): {
+        metricName: string;
+        threshold: number;
+        comparisonOperator: 'GreaterThanThreshold';
+        evaluationPeriods: number;
+        period: number;
+        statistic: 'Average';
+      } => ({
+        metricName: 'MemoryUtilization',
+        threshold,
+        comparisonOperator: 'GreaterThanThreshold' as const,
+        evaluationPeriods: 3,
+        period: 300,
+        statistic: 'Average' as const,
+      }),
+
+      /**
+       * High error rate alarm
+       */
+      highErrors: (threshold: number = 10): {
+        metricName: string;
+        threshold: number;
+        comparisonOperator: 'GreaterThanThreshold';
+        evaluationPeriods: number;
+        period: number;
+        statistic: 'Sum';
+      } => ({
+        metricName: 'Errors',
+        threshold,
+        comparisonOperator: 'GreaterThanThreshold' as const,
+        evaluationPeriods: 1,
+        period: 60,
+        statistic: 'Sum' as const,
+      }),
+
+      /**
+       * High latency alarm
+       */
+      highLatency: (threshold: number = 5000): {
+        metricName: string;
+        threshold: number;
+        comparisonOperator: 'GreaterThanThreshold';
+        evaluationPeriods: number;
+        period: number;
+        statistic: 'Average';
+      } => ({
+        metricName: 'Duration',
+        threshold,
+        comparisonOperator: 'GreaterThanThreshold' as const,
+        evaluationPeriods: 3,
+        period: 300,
+        statistic: 'Average' as const,
+      }),
+
+      /**
+       * Low healthy hosts alarm
+       */
+      lowHealthyHosts: (threshold: number = 1): {
+        metricName: string;
+        namespace: string;
+        threshold: number;
+        comparisonOperator: 'LessThanThreshold';
+        evaluationPeriods: number;
+        period: number;
+        statistic: 'Minimum';
+      } => ({
+        metricName: 'HealthyHostCount',
+        namespace: 'AWS/ApplicationELB',
+        threshold,
+        comparisonOperator: 'LessThanThreshold' as const,
+        evaluationPeriods: 2,
+        period: 60,
+        statistic: 'Minimum' as const,
+      }),
+
+      /**
+       * Queue depth alarm
+       */
+      queueDepth: (threshold: number = 1000): {
+        metricName: string;
+        namespace: string;
+        threshold: number;
+        comparisonOperator: 'GreaterThanThreshold';
+        evaluationPeriods: number;
+        period: number;
+        statistic: 'Average';
+      } => ({
+        metricName: 'ApproximateNumberOfMessagesVisible',
+        namespace: 'AWS/SQS',
+        threshold,
+        comparisonOperator: 'GreaterThanThreshold' as const,
+        evaluationPeriods: 3,
+        period: 300,
+        statistic: 'Average' as const,
+      }),
+
+      /**
+       * Low storage alarm
+       */
+      lowStorage: (threshold: number = 10737418240): {
+        metricName: string;
+        namespace: string;
+        threshold: number;
+        comparisonOperator: 'LessThanThreshold';
+        evaluationPeriods: number;
+        period: number;
+        statistic: 'Average';
+      } => ({ // 10 GB
+        metricName: 'FreeStorageSpace',
+        namespace: 'AWS/RDS',
+        threshold,
+        comparisonOperator: 'LessThanThreshold' as const,
+        evaluationPeriods: 1,
+        period: 300,
+        statistic: 'Average' as const,
+      }),
+    },
+  }
+}