konokenj.cdk-api-mcp-server 0.48.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.record-format-conversion-schema.ts

@@ -0,0 +1,154 @@
+import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as glue from 'aws-cdk-lib/aws-glue';
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+
+const app = new cdk.App();
+
+const SCHEMA_COLUMNS = [
+  {
+    name: 'column_a',
+    type: 'string',
+  },
+  {
+    name: 'column_b',
+    type: 'string',
+  },
+];
+
+class TestStack extends cdk.Stack {
+  public readonly deliveryStreamsToTest: firehose.IDeliveryStream[];
+  public readonly bucket: s3.Bucket;
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+
+    const database = new glue.CfnDatabase(this, 'Database', {
+      databaseInput: {
+        description: 'My database',
+      },
+      catalogId: this.account,
+    });
+
+    const registry = new glue.CfnRegistry(this, 'SchemaRegistry', {
+      name: 'my_schema_registry',
+    });
+
+    const inlineSchemaTable = this.createTableWithInlineSchema(database);
+    const inlineSchemaDeliveryStream = this.createDeliveryStreamWithDataFormatConversion('InlineSchema', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(inlineSchemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: firehose.OutputFormat.PARQUET,
+    });
+
+    const registrySchemaTable = this.createTableWithRegistrySchema(database, registry);
+    const registrySchemaDeliveryStream = this.createDeliveryStreamWithDataFormatConversion('RegistrySchema', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(registrySchemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: firehose.OutputFormat.PARQUET,
+    });
+
+    this.deliveryStreamsToTest = [
+      inlineSchemaDeliveryStream,
+      registrySchemaDeliveryStream,
+    ];
+  }
+
+  private createTableWithInlineSchema(database: glue.CfnDatabase): glue.CfnTable {
+    return new glue.CfnTable(this, 'InlineSchemaTable', {
+      catalogId: database.catalogId,
+      databaseName: database.ref,
+      tableInput: {
+        storageDescriptor: {
+          columns: SCHEMA_COLUMNS,
+        },
+      },
+    });
+  }
+
+  private createTableWithRegistrySchema(database: glue.CfnDatabase, registry: glue.CfnRegistry): glue.CfnTable {
+    const schemaDefinition = JSON.stringify({
+      type: 'record',
+      name: 'MyRecord',
+      fields: SCHEMA_COLUMNS,
+    });
+
+    const schema = new glue.CfnSchema(this, 'Schema', {
+      registry: {
+        arn: registry.attrArn,
+      },
+      compatibility: 'NONE',
+      dataFormat: 'AVRO',
+      name: 'my_schema',
+      schemaDefinition: schemaDefinition,
+    });
+
+    return new glue.CfnTable(this, 'RegistrySchemaTable', {
+      catalogId: database.catalogId,
+      databaseName: database.ref,
+      tableInput: {
+        storageDescriptor: {
+          schemaReference: {
+            schemaVersionId: schema.attrInitialSchemaVersionId,
+          },
+        },
+      },
+    });
+  }
+
+  private createDeliveryStreamWithDataFormatConversion(
+    id: string,
+    dataFormatConversion: firehose.DataFormatConversionProps,
+  ): firehose.DeliveryStream {
+    return new firehose.DeliveryStream(this, id, {
+      destination: new firehose.S3Bucket(this.bucket, {
+        dataOutputPrefix: `success/${id}/`,
+        errorOutputPrefix: `error/${id}/`,
+        bufferingInterval: cdk.Duration.seconds(0),
+        dataFormatConversion: dataFormatConversion,
+      }),
+    });
+  }
+}
+
+const stack = new TestStack(app, 'RecordFormatConversionSchema');
+const testCase = new integ.IntegTest(app, 'RecordFormatConversionSchemaTest', {
+  testCases: [stack],
+});
+
+const assertions = testCase.assertions;
+
+// Test each delivery stream with the same input, and verify that each writes the output to the success prefix
+// Relies on waiting timeout to tell if record format conversion failed.
+stack.deliveryStreamsToTest.forEach(deliveryStream => {
+  const putDataCall = assertions.awsApiCall('Firehose', 'putRecord', {
+    DeliveryStreamName: deliveryStream.deliveryStreamName,
+    Record: {
+      Data: JSON.stringify({
+        Column_A: 'foo',
+        Column_B: 'bar',
+      }),
+    },
+  });
+
+  const waitForResultCall = assertions.awsApiCall('S3', 'listObjectsV2', {
+    Bucket: stack.bucket.bucketName,
+    Prefix: `success/${deliveryStream.node.id}/`,
+  }).expect(integ.ExpectedResult.objectLike({
+    KeyCount: 1,
+  })).waitForAssertions({
+    interval: cdk.Duration.seconds(5),
+    totalTimeout: cdk.Duration.minutes(2),
+  });
+
+  const api = waitForResultCall as integ.AwsApiCall;
+  api.waiterProvider?.addPolicyStatementFromSdkCall('s3', 'ListBucket', [stack.bucket.bucketArn]);
+  api.waiterProvider?.addPolicyStatementFromSdkCall('s3', 'GetObject', [stack.bucket.arnForObjects('*')]);
+  putDataCall.next(waitForResultCall);
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.record-format-conversion.ts

@@ -0,0 +1,178 @@
+import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as glue from 'aws-cdk-lib/aws-glue';
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+
+const app = new cdk.App();
+
+const SCHEMA_COLUMNS = [
+  {
+    name: 'column_a',
+    type: 'string',
+  },
+  {
+    name: 'column_b',
+    type: 'string',
+  },
+];
+
+class TestStack extends cdk.Stack {
+  public readonly bucket: s3.Bucket;
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+
+    const database = new glue.CfnDatabase(this, 'Database', {
+      databaseInput: {
+        description: 'My database',
+      },
+      catalogId: this.account,
+    });
+
+    const schemaTable = this.createTableWithInlineSchema(database);
+
+    // default hive json input with default orc output
+    this.createDeliveryStreamWithDataFormatConversion('DefaultHiveJsonOrc', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.HIVE_JSON,
+      outputFormat: firehose.OutputFormat.ORC,
+    });
+
+    // default openx json input with default parquet output
+    this.createDeliveryStreamWithDataFormatConversion('DefaultOpenXJsonParquet', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: firehose.OutputFormat.PARQUET,
+    });
+
+    // custom hive json input
+    this.createDeliveryStreamWithDataFormatConversion('CustomHiveJson', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: new firehose.HiveJsonInputFormat({
+        timestampParsers: [
+          firehose.TimestampParser.EPOCH_MILLIS,
+          firehose.TimestampParser.fromFormatString('yyyy-MM-dd'),
+        ],
+      }),
+      outputFormat: firehose.OutputFormat.ORC,
+    });
+
+    // custom openx json input
+    this.createDeliveryStreamWithDataFormatConversion('CustomOpenXJson', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: new firehose.OpenXJsonInputFormat({
+        lowercaseColumnNames: false,
+        columnToJsonKeyMappings: { column_yay: 'Column_A' },
+        convertDotsInJsonKeysToUnderscores: true,
+      }),
+      outputFormat: firehose.OutputFormat.PARQUET,
+    });
+
+    // custom orc output
+    this.createDeliveryStreamWithDataFormatConversion('CustomOrc', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.OrcOutputFormat({
+        blockSize: cdk.Size.mebibytes(256),
+        bloomFilterColumns: ['column_a'],
+        bloomFilterFalsePositiveProbability: 0.5,
+        compression: firehose.OrcCompression.NONE,
+        dictionaryKeyThreshold: 0.3,
+        formatVersion: firehose.OrcFormatVersion.V0_11,
+        enablePadding: true,
+        paddingTolerance: 0.4,
+        rowIndexStride: 5000,
+        stripeSize: cdk.Size.mebibytes(32),
+      }),
+    });
+
+    // ORC ZLIB compression
+    this.createDeliveryStreamWithDataFormatConversion('CustomOrcZlib', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.OrcOutputFormat({
+        compression: firehose.OrcCompression.ZLIB,
+        formatVersion: firehose.OrcFormatVersion.V0_12,
+      }),
+    });
+
+    // ORC SNAPPY compression
+    this.createDeliveryStreamWithDataFormatConversion('CustomOrcSnappy', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.OrcOutputFormat({
+        compression: firehose.OrcCompression.SNAPPY,
+      }),
+    });
+
+    // custom parquet output format
+    this.createDeliveryStreamWithDataFormatConversion('CustomParquet', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.ParquetOutputFormat({
+        blockSize: cdk.Size.mebibytes(128),
+        pageSize: cdk.Size.mebibytes(2),
+        compression: firehose.ParquetCompression.UNCOMPRESSED,
+        writerVersion: firehose.ParquetWriterVersion.V2,
+        enableDictionaryCompression: true,
+        maxPadding: cdk.Size.bytes(100),
+      }),
+    });
+
+    // Parquet GZIP compression
+    this.createDeliveryStreamWithDataFormatConversion('CustomParquetGzip', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.ParquetOutputFormat({
+        compression: firehose.ParquetCompression.GZIP,
+        writerVersion: firehose.ParquetWriterVersion.V1,
+      }),
+    });
+
+    // Parquet SNAPPY compression
+    this.createDeliveryStreamWithDataFormatConversion('CustomParquetSnappy', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.ParquetOutputFormat({
+        compression: firehose.ParquetCompression.SNAPPY,
+      }),
+    });
+  }
+
+  private createTableWithInlineSchema(database: glue.CfnDatabase): glue.CfnTable {
+    return new glue.CfnTable(this, 'InlineSchemaTable', {
+      catalogId: database.catalogId,
+      databaseName: database.ref,
+      tableInput: {
+        storageDescriptor: {
+          columns: SCHEMA_COLUMNS,
+        },
+      },
+    });
+  }
+
+  private createDeliveryStreamWithDataFormatConversion(
+    id: string,
+    dataFormatConversion: firehose.DataFormatConversionProps,
+  ): firehose.DeliveryStream {
+    return new firehose.DeliveryStream(this, id, {
+      destination: new firehose.S3Bucket(this.bucket, {
+        dataOutputPrefix: `success/${id}/`,
+        errorOutputPrefix: `error/${id}/`,
+        bufferingInterval: cdk.Duration.seconds(0),
+        dataFormatConversion: dataFormatConversion,
+      }),
+    });
+  }
+}
+
+const stack = new TestStack(app, 'RecordFormatConversion');
+new integ.IntegTest(app, 'RecordFormatConversionTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/README.md

@@ -642,6 +642,15 @@ new CfnOutput(this, 'TheUrl', {
 });
 ```
 
+### Important Function URL Permission Update - Oct 2025
+Starting Oct 2025, Function URL invocation will require two permissions
+- lambda:InvokeFunctionUrl
+- lambda:InvokeFunction (New)
+
+CDK has updated `grantInvokeUrl` and `addFunctionUrl` to add both permission above.
+
+If your existing CDK stack uses `grantInvokeUrl` or `addFunctionUrl`, your next deployment will automatically add the `lambda:InvokeFunction` permission without requiring any code changes. This ensures your Function URLs continue working seamlessly. No additional actions are needed.
+
 ### CORS configuration for Function URLs
 
 If you want your Function URLs to be invokable from a web page in browser, you
@@ -1249,6 +1258,36 @@ const fn = new lambda.Function(this, 'MyFunction', {
   });
 ```
 
+## Lambda with Tenant Isolation
+
+Lambda functions can be configured with tenant isolation to ensure that different tenants never share the same execution environment. This is useful for SaaS applications where you need to guarantee compute isolation between untrusted tenants while using a single Lambda function.
+
+```ts
+const fn = new lambda.Function(this, 'MyFunction', {
+  runtime: lambda.Runtime.NODEJS_18_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
+  tenancyConfig: lambda.TenancyConfig.PER_TENANT,
+});
+```
+
+**Important considerations:**
+
+* **Immutable configuration**: Tenant isolation can only be configured during function creation and cannot be modified on existing functions.
+* **Incompatible features**: The following features are not compatible with tenant isolation and will result in CloudFormation deployment errors:
+  * **Provisioned Concurrency**
+  * **Function URLs**
+  * **SnapStart**
+  * **Event Source Mappings** (except API Gateway):
+    * ❌ SQS
+    * ❌ DynamoDB
+    * ❌ Kinesis
+    * ❌ MSK
+    * ❌ Self-managed Kafka
+    * ✅ API Gateway (supported)
+
+CDK validates these restrictions at synthesis time and provides clear error messages when incompatible features are configured.
+
 ### Legacy Log Retention
 
 As an alternative to providing a custom, user controlled log group, the legacy `logRetention` property can be used to set a different expiration period.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.binary-payload.ts

@@ -10,7 +10,7 @@ const app = new App({
 const stack = new Stack(app, 'IntegBinaryPayload');
 
 const fn = new Function(stack, 'fn', {
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: Code.fromInline(`
     exports.handler = async (event) => {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.logging-config.ts

@@ -18,49 +18,49 @@ const logGroup = new logs.LogGroup(stack, 'MyLogGroupWithLogGroupName', {
 new Function(stack, 'LambdaWithLogGroup', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   logGroup: logGroup,
 });
 
 new Function(stack, 'LambdaWithLogGroupAndNoLogGroupName', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   logGroup: new logs.LogGroup(stack, 'MyLogGroupWithoutLogGroupName'),
 });
 
 new Function(stack, 'LambdaWithTextFormat', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   logFormat: LogFormat.TEXT,
 });
 
 new Function(stack, 'LambdaWithJSONFormat', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   logFormat: LogFormat.JSON,
 });
 
 new Function(stack, 'LambdaWithTextLoggingFormat', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   logFormat: LoggingFormat.TEXT,
 });
 
 new Function(stack, 'LambdaWithJSONLoggingFormat', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   logFormat: LoggingFormat.JSON,
 });
 
 new Function(stack, 'LambdaWithLogLevel', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   logFormat: LogFormat.JSON,
   systemLogLevel: SystemLogLevel.INFO,
   applicationLogLevel: ApplicationLogLevel.INFO,
@@ -69,7 +69,7 @@ new Function(stack, 'LambdaWithLogLevel', {
 new Function(stack, 'LambdaWithLogLevelV2', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   loggingFormat: LoggingFormat.JSON,
   systemLogLevelV2: SystemLogLevel.INFO,
   applicationLogLevelV2: ApplicationLogLevel.INFO,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.multi-tenancy.ts

@@ -0,0 +1,24 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { Function, InlineCode, Runtime, TenancyConfig } from 'aws-cdk-lib/aws-lambda';
+
+const app = new App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const stack = new Stack(app, 'aws-cdk-lambda-multi-tenancy');
+
+new Function(stack, 'MultiTenantFunction', {
+  code: new InlineCode('foo'),
+  handler: 'index.handler',
+  runtime: Runtime.NODEJS_18_X,
+  tenancyConfig: TenancyConfig.PER_TENANT,
+});
+
+new integ.IntegTest(app, 'lambda-multi-tenancy', {
+  testCases: [stack],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.params-and-secrets.ts

@@ -46,7 +46,7 @@ class StackUnderTest extends Stack {
     });
 
     const lambdaFunction = new Function(this, 'MyFunc', {
-      runtime: Runtime.NODEJS_18_X,
+      runtime: Runtime.NODEJS_20_X,
       handler: 'index.handler',
       code: Code.fromAsset(path.join(__dirname, 'params-and-secrets-handler')),
       architecture: props.architecture,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime-management.ts

@@ -13,7 +13,7 @@ const stack = new Stack(app, 'aws-cdk-lambda-runtime-management');
 new Function(stack, 'Lambda', {
   code: new InlineCode('foo'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   runtimeManagementMode: RuntimeManagementMode.AUTO,
 });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime.fromasset.ts

@@ -10,20 +10,35 @@ const app = new App({
 });
 const stack = new Stack(app, 'aws-cdk-lambda-runtime-fromasset');
 
-const lambdaFunction = new Function(stack, 'MyFunction', {
+const lambdaFunctionJava21 = new Function(stack, 'MyFunctionJava21', {
   runtime: Runtime.JAVA_21,
   handler: 'com.mycompany.app.LambdaMethodHandler::handleRequest',
   code: Code.fromAsset(path.join(__dirname, 'my-app-1.0-SNAPSHOT.zip')),
 });
 
+const lambdaFunctionJava25 = new Function(stack, 'MyFunctionJava25', {
+  runtime: Runtime.JAVA_25,
+  handler: 'com.mycompany.app.LambdaMethodHandler::handleRequest',
+  code: Code.fromAsset(path.join(__dirname, 'my-app-1.0-SNAPSHOT.zip')),
+});
+
 const integTest = new integ.IntegTest(app, 'Integ', { testCases: [stack] });
 
-const invoke = integTest.assertions.invokeFunction({
-  functionName: lambdaFunction.functionName,
+const invokeJava21 = integTest.assertions.invokeFunction({
+  functionName: lambdaFunctionJava21.functionName,
+  payload: '123',
+});
+
+invokeJava21.expect(integ.ExpectedResult.objectLike({
+  Payload: '"123"',
+}));
+
+const invokeJava25 = integTest.assertions.invokeFunction({
+  functionName: lambdaFunctionJava25.functionName,
   payload: '123',
 });
 
-invoke.expect(integ.ExpectedResult.objectLike({
+invokeJava25.expect(integ.ExpectedResult.objectLike({
   Payload: '"123"',
 }));
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.runtime.inlinecode.ts

@@ -55,12 +55,12 @@ const python313 = new Function(stack, 'PYTHON_3_13', {
 });
 new CfnOutput(stack, 'PYTHON_3_13-functionName', { value: python313.functionName });
 
-const node18xfn = new Function(stack, 'NODEJS_18_X', {
-  code: new InlineCode('exports.handler = async function(event) { return "success" }'),
+const python314 = new Function(stack, 'PYTHON_3_14', {
+  code: new InlineCode('def handler(event, context):\n  return "success"'),
   handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.PYTHON_3_14,
 });
-new CfnOutput(stack, 'NODEJS_18_X-functionName', { value: node18xfn.functionName });
+new CfnOutput(stack, 'PYTHON_3_14-functionName', { value: python314.functionName });
 
 const node20xfn = new Function(stack, 'NODEJS_20_X', {
   code: new InlineCode('exports.handler = async function(event) { return "success" }'),
@@ -76,6 +76,13 @@ const node22xfn = new Function(stack, 'NODEJS_22_X', {
 });
 new CfnOutput(stack, 'NODEJS_22_X-functionName', { value: node22xfn.functionName });
 
+const node24xfn = new Function(stack, 'NODEJS_24_X', {
+  code: new InlineCode('exports.handler = async function(event) { return "success" }'),
+  handler: 'index.handler',
+  runtime: Runtime.NODEJS_24_X,
+});
+new CfnOutput(stack, 'NODEJS_24_X-functionName', { value: node24xfn.functionName });
+
 new integ.IntegTest(app, 'lambda-runtime-inlinecode', {
   testCases: [stack],
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda-nodejs/integ.dependencies-pnpm.ts

@@ -14,7 +14,7 @@ const stack = new cdk.Stack(app, 'TestStack');
 
 const handler = new lambda.NodejsFunction(stack, 'Function', {
   entry: path.join(__dirname, 'integ-handlers/pnpm/dependencies-pnpm.ts'),
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   bundling: {
     minify: true,
     // Will be installed, not bundled

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda-nodejs/integ.function-exclude-smithy-models.ts

@@ -14,7 +14,7 @@ class TestStack extends Stack {
 
     this.lambdaFunction = new lambda.NodejsFunction(this, 'NodeJsFunction', {
       entry: path.join(__dirname, 'integ-handlers/dependencies.ts'),
-      runtime: Runtime.NODEJS_18_X,
+      runtime: Runtime.NODEJS_20_X,
     });
   }
 }
@@ -25,7 +25,7 @@ const app = new App({
     [LAMBDA_NODEJS_SDK_V3_EXCLUDE_SMITHY_PACKAGES]: true,
   },
 });
-const stack = new TestStack(app, 'cdk-integ-lambda-nodejs-18-exclude-smithy');
+const stack = new TestStack(app, 'cdk-integ-lambda-nodejs-20-exclude-smithy');
 new IntegTest(app, 'NodeJsFunctionExcludeSmithyInteg', {
   testCases: [stack],
   diffAssets: true,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda-nodejs/integ.nodejs.build.images.ts

@@ -12,7 +12,7 @@ class TestStack extends Stack {
     super(scope, id, props);
 
     const runtimes: Runtime[]= [
-      Runtime.NODEJS_18_X, Runtime.NODEJS_20_X, Runtime.NODEJS_LATEST, Runtime.NODEJS_22_X,
+      Runtime.NODEJS_20_X, Runtime.NODEJS_LATEST, Runtime.NODEJS_22_X,
     ];
 
     const uniqueRuntimes: Runtime[] = runtimes.filter((value, index, array) => array.findIndex(value1 => value1.runtimeEquals(value)) === index);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-logs/README.md

@@ -545,6 +545,10 @@ new logs.Transformer(this, 'Transformer', {
 
 For more details on CloudWatch Logs transformation processors, refer to the [AWS documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Processors.html).
 
+### Usage of metric filters on transformed logs
+
+In order to use the transformed logs as search pattern, set the parameter `applyOnTransformedLogs: true` in the MetricFilterProps.
+
 ## Notes
 
 Be aware that Log Group ARNs will always have the string `:*` appended to

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-logs/integ.metricfilter-apply-on-transformed-logs.ts

@@ -0,0 +1,29 @@
+import { App, RemovalPolicy, Stack, StackProps } from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { FilterPattern, LogGroup, MetricFilter } from 'aws-cdk-lib/aws-logs';
+
+class TestStack extends Stack {
+  constructor(scope: App, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const logGroup = new LogGroup(this, 'LogGroup', {
+      removalPolicy: RemovalPolicy.DESTROY,
+    });
+
+    new MetricFilter(this, 'MetricFilter', {
+      logGroup,
+      metricNamespace: 'MyApp',
+      metricName: 'Latency',
+      filterPattern: FilterPattern.exists('$.latency'),
+      applyOnTransformedLogs: true,
+    });
+  }
+}
+
+const app = new App();
+const testCase = new TestStack(app, 'aws-cdk-metricfilter-apply-on-transformed-logs-integ');
+
+new IntegTest(app, 'metricfilter-apply-on-transformed-logs', {
+  testCases: [testCase],
+});
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-logs/integ.subscriptionfilter.ts

@@ -11,7 +11,7 @@ class SubscriptionFilterIntegStack extends Stack {
     const logGroup = new LogGroup(this, 'LogGroup');
 
     const fn = new Function(this, 'Function', {
-      runtime: Runtime.NODEJS_18_X,
+      runtime: Runtime.NODEJS_20_X,
       handler: 'index.handler',
       code: Code.fromInline('foo'),
     });