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

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
@@ -1177,7 +1186,7 @@ const version = fn.currentVersion;
 You can use Application AutoScaling to automatically configure the provisioned concurrency for your functions. AutoScaling can be set to track utilization or be based on a schedule. To configure AutoScaling on a function alias:
 
 ```ts
-import * as autoscaling from 'aws-cdk-lib/aws-autoscaling';
+import * as appscaling from 'aws-cdk-lib/aws-applicationautoscaling';
 
 declare const fn: lambda.Function;
 const alias = fn.addAlias('prod');
@@ -1192,7 +1201,7 @@ as.scaleOnUtilization({
 
 // Configure Scheduled Scaling
 as.scaleOnSchedule('ScaleUpInTheMorning', {
-  schedule: autoscaling.Schedule.cron({ hour: '8', minute: '0'}),
+  schedule: appscaling.Schedule.cron({ hour: '8', minute: '0'}),
   minCapacity: 20,
 });
 ```
@@ -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.lambda-policy-with-token-resolution.ts

@@ -0,0 +1,46 @@
+import * as cdk from 'aws-cdk-lib';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+const stack = new cdk.Stack(app, 'stack');
+
+const mappingName = 'testmapping';
+const mapping = new cdk.CfnMapping(stack, 'testmapping', {
+  mapping: {
+    us: {
+      regionalModels:
+        'arn:aws:bedrock:us-west-2::foundation-model/amazon.nova-lite-v1:0',
+    },
+  },
+});
+mapping.overrideLogicalId(mappingName);
+
+const func = new lambda.Function(stack, 'test-function', {
+  code: new lambda.InlineCode('exports.handler = async (event) => { console.log(event); return {\'statusCode\': 200, \'body\': \'\'}; }'),
+  runtime: lambda.Runtime.NODEJS_20_X,
+  handler: 'index.handler',
+});
+
+// Literal resources in statement
+func.addToRolePolicy(new iam.PolicyStatement({
+  actions: ['bedrock:Invoke*'],
+  resources: [
+    '*',
+  ],
+}));
+
+// Array token resources in statement
+func.addToRolePolicy(new iam.PolicyStatement({
+  actions: ['bedrock:Invoke*'],
+  resources: cdk.Fn.split(',', cdk.Fn.findInMap(mappingName, 'us', 'regionalModels')),
+}));
+
+new integ.IntegTest(app, 'lambda-policy-with-token-resolution', {
+  testCases: [stack],
+});

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/README.md

@@ -108,8 +108,8 @@ With the `@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion` disabled, the runt
 
 ## Lock file
 
-The `NodejsFunction` requires a dependencies lock file (`yarn.lock`, `pnpm-lock.yaml`, `bun.lockb` or
-`package-lock.json`). When bundling in a Docker container, the path containing this lock file is
+The `NodejsFunction` requires a dependencies lock file (`yarn.lock`, `pnpm-lock.yaml`, `bun.lockb`,
+`bun.lock` or `package-lock.json`). When bundling in a Docker container, the path containing this lock file is
 used as the source (`/asset-input`) for the volume mounted in the container.
 
 By default, the construct will try to automatically determine your project lock file.
@@ -201,7 +201,7 @@ new nodejs.NodejsFunction(this, 'my-handler', {
 
 The modules listed in `nodeModules` must be present in the `package.json`'s dependencies or
 installed. The same version will be used for installation. The lock file (`yarn.lock`,
-`pnpm-lock.yaml`, `bun.lockb` or `package-lock.json`) will be used along with the right installer (`yarn`,
+`pnpm-lock.yaml`, `bun.lockb`, `bun.lock` or `package-lock.json`) will be used along with the right installer (`yarn`,
 `pnpm`, `bun` or `npm`).
 
 When working with `nodeModules` using native dependencies, you might want to force bundling in a

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

@@ -0,0 +1,50 @@
+import * as path from 'path';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+
+const stack = new cdk.Stack(app, 'TestStack');
+
+const handler = new lambda.NodejsFunction(stack, 'Function', {
+  entry: path.join(__dirname, 'integ-handlers/bun_lock/dependencies-bun.ts'),
+  runtime: Runtime.NODEJS_22_X,
+  bundling: {
+    minify: true,
+    // Will be installed, not bundled
+    // (axios is a package with sub-dependencies,
+    // will be used to ensure bun bundling works as expected)
+    nodeModules: ['axios'],
+    forceDockerBundling: true,
+  },
+
+  // To (re-)generate this lockfile:
+  // 1. Ensure your local version of bun matches the version in packages/aws-cdk-lib/aws-lambda-nodejs/lib/Dockerfile
+  // 2. `cd` to `packages/@aws-cdk-testing/framework-integ/test/aws-lambda-nodejs/test/integ-handlers/bun`
+  // 3. Rename the `_package.json` file to `package.json`
+  // 4. Run `bun install`
+  depsLockFilePath: path.join(__dirname, 'integ-handlers/bun_lock/bun.lock'),
+});
+
+const integ = new IntegTest(app, 'BunTest', {
+  testCases: [stack],
+  stackUpdateWorkflow: false, // this will tell the runner to not check in assets.
+});
+
+const response = integ.assertions.invokeFunction({
+  functionName: handler.functionName,
+});
+response.expect(
+  ExpectedResult.objectLike({
+    // expect invoking without error
+    StatusCode: 200,
+    ExecutedVersion: '$LATEST',
+    Payload: 'null',
+  }),
+);

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

@@ -199,7 +199,6 @@ the name `Namespace/MetricName`.
 
 You can expose a metric on a metric filter by calling the `MetricFilter.metric()` API.
 This has a default of `statistic = 'avg'` if the statistic is not set in the `props`.
-Additionally, if the metric filter was created with a dimension map, those dimensions will be included in the metric.
 
 ```ts
 declare const logGroup: logs.LogGroup;
@@ -403,6 +402,10 @@ new logs.QueryDefinition(this, 'QueryDefinition', {
       'loggingType = "ERROR"',
       'loggingMessage = "A very strange error occurred!"',
     ],
+    statsStatements: [
+      'count(loggingMessage) as loggingErrors',
+      'count(differentLoggingMessage) as differentLoggingErrors',
+    ],
     sort: '@timestamp desc',
     limit: 20,
   }),
@@ -481,6 +484,71 @@ new logs.LogGroup(this, 'LogGroup', {
 });
 ```
 
+## Transformer
+
+A log transformer enables transforming log events into a different format, making them easier
+to process and analyze. You can transform logs from different sources into standardized formats
+that contain relevant, source-specific information. Transformations are performed at the time of log ingestion.
+Transformers support several types of processors which can be chained into a processing pipeline (subject to some restrictions, see [Usage Limits](#usage-limits)).
+
+### Processor Types
+
+1. **Parser Processors**: Parse string log events into structured log events. These are configurable parsers created using `ParserProcessor`, and support conversion to a format like Json, extracting fields from CSV input, converting vended sources to [OCSF](https://schema.ocsf.io/1.1.0/) format, regex parsing using Grok patterns or key-value parsing. Refer [configurable parsers](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Processors.html#CloudWatch-Logs-Transformation-Configurable) for more examples.
+
+2. **Vended Log Parsers**: Parse log events from vended sources into structured log events. These are created using `VendedLogParser`, and support conversion from sources such as AWS WAF, PostGres, Route53, CloudFront and VPC. These parsers are not configurable, meaning these can be added to the pipeline but do not accept any properties or configurations. Refer [vended log parsers](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Processors.html#CloudWatch-Logs-Transformation-BuiltIn) for more examples.
+
+3. **String Mutators**: Perform operations on string values in a field of a log event and are created using `StringMutatorProcessor`. These can be used to format string values in the log event such as changing case, removing trailing whitespaces or extracting values from a string field by splitting the string or regex backreferences. Refer [string mutators](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Processors.html#CloudWatch-Logs-Transformation-StringMutate) for more examples.
+
+4. **JSON Mutators**: Perform operation on JSON log events and are created using `JsonMutatorProcessor`. These processors can be used to enrich log events by adding new fields, deleting, moving, renaming fields, copying values to other fields or converting a list of key-value pairs to a map. Refer [JSON mutators](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Processors.html#CloudWatch-Logs-Transformation-JSONMutate) for more examples.
+
+5. **Data Converters**: Convert the data into different formats and are created using `DataConverterProcessor`. These can be used to convert values in a field to datatypes such as integers, string, double and boolean or to convert dates and times to different formats. Refer [datatype processors](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Transformation-Processors.html#CloudWatch-Logs-Transformation-Datatype) for more examples.
+
+### Usage Limits
+
+- A transformer can have a maximum of 20 processors
+- At least one parser-type processor is required
+- Maximum of 5 parser-type processors allowed
+- AWS vended log parser (if used) must be the first processor
+- Only one parseToOcsf processor, one grok processor, one addKeys processor, and one copyValue processor allowed per transformer
+- Transformers can only be used with log groups in the Standard log class
+
+Example:
+
+```ts
+
+// Create a log group
+const logGroup = new logs.LogGroup(this, 'MyLogGroup');
+
+// Create a JSON parser processor
+const jsonParser = new logs.ParserProcessor({
+  type: logs.ParserProcessorType.JSON
+});
+
+// Create a processor to add keys
+const addKeysProcessor = new logs.JsonMutatorProcessor({
+  type: logs.JsonMutatorType.ADD_KEYS,
+  addKeysOptions: {
+    entries: [{
+      key: 'metadata.transformed_in',
+      value: 'CloudWatchLogs'
+    }]
+  }
+});
+
+// Create a transformer with these processors
+new logs.Transformer(this, 'Transformer', {
+  transformerName: 'MyTransformer',
+  logGroup: logGroup,
+  transformerConfig: [jsonParser, addKeysProcessor]
+});
+```
+
+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.loggroup-transformer.ts

@@ -0,0 +1,37 @@
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import { JsonMutatorType, LogGroup, ParserProcessorType, ParserProcessor, JsonMutatorProcessor } from 'aws-cdk-lib/aws-logs';
+
+class TransformerIntegStack extends Stack {
+  constructor(scope: App, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const logGroup = new LogGroup(this, 'MyLogGroup');
+    const jsonParser = new ParserProcessor({
+      type: ParserProcessorType.JSON,
+      jsonOptions: { source: 'customField' },
+    });
+
+    const addKeysProcesor = new JsonMutatorProcessor({
+      type: JsonMutatorType.ADD_KEYS,
+      addKeysOptions: {
+        entries: [
+          { key: 'test_key1', value: 'test_value1', overwriteIfExists: true },
+          { key: 'test_key2', value: 'test_value2' },
+          { key: 'test_key3', value: 'test_value3', overwriteIfExists: false },
+        ],
+      },
+    });
+
+    logGroup.addTransformer('Transformer', {
+      transformerName: 'MyTransformer',
+      transformerConfig: [jsonParser, addKeysProcesor],
+    });
+  }
+}
+
+const app = new App();
+const testCase = new TransformerIntegStack(app, 'aws-cdk-transformer-integ');
+new IntegTest(app, 'transformer-create', {
+  testCases: [testCase],
+});

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.save-logs-insights-query-definition.ts

@@ -11,13 +11,14 @@ class LogsInsightsQueryDefinitionIntegStack extends Stack {
       removalPolicy: RemovalPolicy.DESTROY,
     });
 
-    // Test query creation with single parse and filter statements
+    // Test query creation with single parse, filter, and sort statements
     new QueryDefinition(this, 'QueryDefinition', {
       queryDefinitionName: 'QueryDefinition',
       queryString: new QueryString({
         fields: ['@timestamp', '@message'],
         parse: '@message "[*] *" as loggingType, loggingMessage',
         filter: 'loggingType = "ERROR"',
+        stats: 'count(loggingMessage) as loggingErrors',
         sort: '@timestamp desc',
         limit: 20,
         display: 'loggingMessage',
@@ -25,7 +26,7 @@ class LogsInsightsQueryDefinitionIntegStack extends Stack {
       logGroups: [logGroup],
     });
 
-    // Test query creation with multiple parse and filter statements
+    // Test query creation with multiple parse, filter, and stats statements
     new QueryDefinition(this, 'QueryDefinitionWithMultipleStatements', {
       queryDefinitionName: 'QueryDefinitionWithMultipleStatements',
       queryString: new QueryString({
@@ -38,6 +39,10 @@ class LogsInsightsQueryDefinitionIntegStack extends Stack {
           'loggingType = "ERROR"',
           'loggingMessage = "A very strange error occurred!"',
         ],
+        statsStatements: [
+          'count(loggingMessage) as loggingErrors',
+          'count(differentLoggingMessage) as differentLoggingErrors',
+        ],
         sort: '@timestamp desc',
         limit: 20,
         display: 'loggingMessage',

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-logs/integ.transformer.ts

@@ -0,0 +1,27 @@
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import { LogGroup, ParserProcessorType, ParserProcessor, Transformer } from 'aws-cdk-lib/aws-logs';
+
+class TransformerIntegStack extends Stack {
+  constructor(scope: App, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const logGroup = new LogGroup(this, 'MyLogGroup');
+    const jsonParser = new ParserProcessor({
+      type: ParserProcessorType.JSON,
+      jsonOptions: { source: 'customField' },
+    });
+
+    new Transformer(this, 'Transformer', {
+      transformerName: 'MyTransformer',
+      logGroup: logGroup,
+      transformerConfig: [jsonParser],
+    });
+  }
+}
+
+const app = new App();
+const testCase = new TransformerIntegStack(app, 'aws-cdk-transformer-integ');
+new IntegTest(app, 'transformer-create', {
+  testCases: [testCase],
+});