Amazon Data Firehose will send logs to CloudWatch when data transformation or data

delivery fails. The CDK will enable logging by default and create a CloudWatch LogGroup

When creating a destination, you can provide an `ILoggingConfig`, which can either be an `EnableLogging` or `DisableLogging` instance.

If you use `EnableLogging`, the CDK will create a CloudWatch LogGroup and LogStream with all CloudFormation default settings for you, or you can optionally

- VTL mapping template changes for AppSync Resolvers and Functions.

- Schema changes for AppSync GraphQL Apis.

**⚠ Note #1**: This command deliberately introduces drift in CloudFormation stacks in order to speed up deployments.

For this reason, only use it for development purposes.

**Never use this flag for your production deployments**!

import { ISDK, SdkProvider } from './aws-auth';

import { EnvironmentResources } from './environment-resources';

import { CfnEvaluationException } from './evaluate-cloudformation-template';

import { tryHotswapDeployment } from './hotswap-deployments';

import { addMetadataAssetsToManifest } from '../assets';

import { Tag } from '../cdk-toolkit';

readonly hotswap?: HotswapMode;

/**

: templateParams.supplyAll(finalParameterValues);

const hotswapMode = options.hotswap ?? HotswapMode.FULL_DEPLOYMENT;

if (await canSkipDeploy(options, cloudFormationStack, stackParams.hasChanges(cloudFormationStack.parameters))) {

debug(`${deployName}: skipping deployment (use --force to override)`);

// attempt to short-circuit the deployment if possible

try {

const hotswapDeploymentResult = await tryHotswapDeployment(

);

if (hotswapDeploymentResult) {

return hotswapDeploymentResult;

import { CredentialsOptions, SdkForEnvironment, SdkProvider } from './aws-auth/sdk-provider';

import { deployStack, DeployStackResult, destroyStack, DeploymentMethod } from './deploy-stack';

import { EnvironmentResources, EnvironmentResourcesRegistry } from './environment-resources';

import { loadCurrentTemplateWithNestedStacks, loadCurrentTemplate, RootTemplateWithNestedStacks } from './nested-stack-helpers';

import { determineAllowCrossAccountAssetPublishing } from './util/checks';

import { CloudFormationStack, Template, ResourcesToImport, ResourceIdentifierSummaries, stabilizeStack, uploadStackTemplateAssets } from './util/cloudformation';

readonly hotswap?: HotswapMode;

/**

ci: options.ci,

rollback: options.rollback,

hotswap: options.hotswap,

extraUserAgent: options.extraUserAgent,

resourcesToImport: options.resourcesToImport,

overrideTemplate: options.overrideTemplate,

import { print } from '../logging';

import { isHotswappableAppSyncChange } from './hotswap/appsync-mapping-templates';

import { isHotswappableCodeBuildProjectChange } from './hotswap/code-build-projects';

import { isHotswappableEcsServiceChange } from './hotswap/ecs-services';

import { isHotswappableLambdaFunctionChange } from './hotswap/lambda-functions';

import { skipChangeForS3DeployCustomResourcePolicy, isHotswappableS3BucketDeploymentChange } from './hotswap/s3-bucket-deployments';

const pLimit: typeof import('p-limit') = require('p-limit');

type HotswapDetector = (

) => Promise<ChangeHotswapResult>;

const RESOURCE_DETECTORS: { [key: string]: HotswapDetector } = {

export async function tryHotswapDeployment(

sdkProvider: SdkProvider, assetParams: { [key: string]: string },

cloudFormationStack: CloudFormationStack, stackArtifact: cxapi.CloudFormationStackArtifact,

): Promise<DeployStackResult | undefined> {

// resolve the environment, so we can substitute things like AWS::Region in CFN expressions

const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);

const stackChanges = cfn_diff.fullDiff(currentTemplate.deployedRootTemplate, stackArtifact.template);

const { hotswappableChanges, nonHotswappableChanges } = await classifyResourceChanges(

);

logNonHotswappableChanges(nonHotswappableChanges, hotswapMode);

evaluateCfnTemplate: EvaluateCloudFormationTemplate,

sdk: ISDK,

nestedStackNames: { [nestedStackName: string]: NestedStackTemplates },

): Promise<ClassifiedResourceChanges> {

const resourceDifferences = getStackResourceDifferences(stackChanges);

// gather the results of the detector functions

for (const [logicalId, change] of Object.entries(resourceDifferences)) {

if (change.newValue?.Type === 'AWS::CloudFormation::Stack' && change.oldValue?.Type === 'AWS::CloudFormation::Stack') {

hotswappableResources.push(...nestedHotswappableResources.hotswappableChanges);

nonHotswappableResources.push(...nestedHotswappableResources.nonHotswappableChanges);

const resourceType: string = hotswappableChangeCandidate.newValue.Type;

if (resourceType in RESOURCE_DETECTORS) {

// run detector functions lazily to prevent unhandled promise rejections

} else {

reportNonHotswappableChange(nonHotswappableResources, hotswappableChangeCandidate, undefined, 'This resource type is not supported for hotswap deployments');

}

nestedStackTemplates: { [nestedStackName: string]: NestedStackTemplates },

evaluateCfnTemplate: EvaluateCloudFormationTemplate,

sdk: ISDK,

): Promise<ClassifiedResourceChanges> {

const nestedStack = nestedStackTemplates[logicalId];

if (!nestedStack.physicalName) {

nestedStackTemplates[logicalId].deployedTemplate, nestedStackTemplates[logicalId].generatedTemplate,

);

type Exclude = { [key: string]: Exclude | true }

import * as AWS from 'aws-sdk';

import { ISDK } from '../aws-auth';

import { EvaluateCloudFormationTemplate } from '../evaluate-cloudformation-template';

export async function isHotswappableEcsServiceChange(

): Promise<ChangeHotswapResult> {

// the only resource change we can evaluate here is an ECS TaskDefinition

if (change.newValue.Type !== 'AWS::ECS::TaskDefinition') {

const registerTaskDefResponse = await sdk.ecs().registerTaskDefinition(lowercasedTaskDef).promise();

const taskDefRevArn = registerTaskDefResponse.taskDefinition?.taskDefinitionArn;

// Step 2 - update the services using that TaskDefinition to point to the new TaskDefinition Revision

const servicePerClusterUpdates: { [cluster: string]: Array<{ promise: Promise<any>; ecsService: EcsService }> } = {};

for (const ecsService of ecsServicesReferencingTaskDef) {

cluster: clusterName,

forceNewDeployment: true,

deploymentConfiguration: {

},

}).promise(),

ecsService: ecsService,

import { CloudExecutable } from './api/cxapp/cloud-executable';

import { Deployments } from './api/deployments';

import { GarbageCollector } from './api/garbage-collection/garbage-collector';

import { findCloudWatchLogGroups } from './api/logs/find-cloudwatch-logs';

import { CloudWatchLogEventMonitor } from './api/logs/logs-monitor';

import { createDiffChangeSet, ResourcesToImport } from './api/util/cloudformation';

warning('⚠️ They should only be used for development - never use them for your production Stacks!\n');

}

const stacks = stackCollection.stackArtifacts;

const stackOutputs: { [key: string]: any } = { };

ci: options.ci,

rollback: options.rollback,

hotswap: options.hotswap,

extraUserAgent: options.extraUserAgent,

assetParallelism: options.assetParallelism,

ignoreNoStacks: options.ignoreNoStacks,

assetParallelism: argv['asset-parallelism'],

assetPrebuild: argv['asset-prebuild'],

ignoreNoStacks: argv['ignore-no-stacks'],

unstable: argv.unstable,

});

}