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

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

@@ -125,6 +125,102 @@ const s3Destination = new firehose.S3Bucket(bucket, {
 });
 ```
 
+## Data Format Conversion
+
+Data format conversion allows automatic conversion of inputs from JSON to either Parquet or ORC.
+Converting JSON records to columnar formats like Parquet or ORC can help speed up analytical querying while also increasing compression efficiency.
+When data format conversion is specified, it automatically enables Snappy compression on the output.
+
+Only S3 Destinations support data format conversion.
+
+An example of defining an S3 destination configured with data format conversion:
+
+```ts
+declare const bucket: s3.Bucket;
+declare const schemaGlueTable: glue.CfnTable;
+const s3Destination = new firehose.S3Bucket(bucket, {
+  dataFormatConversion: {
+    schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaGlueTable),
+    inputFormat: firehose.InputFormat.OPENX_JSON,
+    outputFormat: firehose.OutputFormat.PARQUET,
+  }
+});
+```
+
+When data format conversion is enabled, the Delivery Stream's buffering size must be at least 64 MiB. 
+Additionally, the default buffering size is changed from 5 MiB to 128 MiB. This mirrors the Cloudformation behavior.
+
+You can only parse JSON and transform it into either Parquet or ORC:
+- to read JSON using OpenX parser, choose `InputFormat.OPENX_JSON`.
+- to read JSON using Hive parser, choose `InputFormat.HIVE_JSON`.
+- to transform into Parquet, choose `OutputFormat.PARQUET`.
+- to transform into ORC, choose `OutputFormat.ORC`.
+
+The following subsections explain how to specify advanced configuration options for each input and output format if the defaults are not desirable
+
+### Input Format: OpenX JSON
+
+Example creation of custom OpenX JSON InputFormat:
+
+```ts
+const inputFormat = new firehose.OpenXJsonInputFormat({
+  lowercaseColumnNames: false,
+  columnToJsonKeyMappings: {"ts": "timestamp"},
+  convertDotsInJsonKeysToUnderscores: true,
+})
+```
+
+### Input Format: Hive JSON
+
+Example creation of custom Hive JSON InputFormat:
+
+```ts
+const inputFormat = new firehose.HiveJsonInputFormat({
+  timestampParsers: [
+    firehose.TimestampParser.fromFormatString('yyyy-MM-dd'),
+    firehose.TimestampParser.EPOCH_MILLIS,
+  ]
+})
+```
+
+Hive JSON allows you to specify custom timestamp formats to parse. The syntax of the format string is Joda Time.
+
+To parse timestamps formatted as milliseconds since epoch, use the convenience constant `TimestampParser.EPOCH_MILLIS`.
+
+### Output Format: Parquet
+
+Example of a custom Parquet OutputFormat, with all values changed from the defaults.
+
+```ts
+const outputFormat = new firehose.ParquetOutputFormat({
+  blockSize: Size.mebibytes(512),
+  compression: firehose.ParquetCompression.UNCOMPRESSED,
+  enableDictionaryCompression: true,
+  maxPadding: Size.bytes(10),
+  pageSize: Size.mebibytes(2),
+  writerVersion: firehose.ParquetWriterVersion.V2,
+})
+```
+
+### Output Format: ORC
+
+Example creation of custom ORC OutputFormat, with all values changed from the defaults.
+
+```ts
+const outputFormat = new firehose.OrcOutputFormat({
+  formatVersion: firehose.OrcFormatVersion.V0_11,
+  blockSize: Size.mebibytes(256),
+  compression: firehose.OrcCompression.NONE,
+  bloomFilterColumns: ['columnA'],
+  bloomFilterFalsePositiveProbability: 0.1,
+  dictionaryKeyThreshold: 0.7,
+  enablePadding: true,
+  paddingTolerance: 0.2,
+  rowIndexStride: 9000,
+  stripeSize: Size.mebibytes(32),
+})
+```
+
 ## Server-side Encryption
 
 Enabling server-side encryption (SSE) requires Amazon Data Firehose to encrypt all data

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

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.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.inlinecode.ts

@@ -55,13 +55,6 @@ 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" }'),
-  handler: 'index.handler',
-  runtime: Runtime.NODEJS_18_X,
-});
-new CfnOutput(stack, 'NODEJS_18_X-functionName', { value: node18xfn.functionName });
-
 const node20xfn = new Function(stack, 'NODEJS_20_X', {
   code: new InlineCode('exports.handler = async function(event) { return "success" }'),
   handler: 'index.handler',

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'),
     });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-opensearchservice/integ.opensearch.min.ts

@@ -11,6 +11,7 @@ class TestStack extends Stack {
       opensearch.EngineVersion.OPENSEARCH_2_13,
       opensearch.EngineVersion.OPENSEARCH_2_15,
       opensearch.EngineVersion.OPENSEARCH_2_17,
+      opensearch.EngineVersion.OPENSEARCH_3_1,
     ];
 
     // deploy opensearch domain with minimal configuration

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/integ.cluster-data-api-to-imported-cluster.ts

@@ -14,7 +14,7 @@ const stack = new cdk.Stack(app, 'cluster-data-api-to-imported-cluster');
 const vpc = new ec2.Vpc(stack, 'VPC');
 
 const func = new lambda.Function(stack, 'Function', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: lambda.Code.fromInline('exports.handler = async (event) => { return "hello"; }'),
 });