feat(core): addInfoV2 method for suppressible info Annotations (#34872)

### Issue # (if applicable)

Closes #34871

### Reason for this change

> This feature request proposes add Annotations.addInfoV2() method to provide CDK developers the way to suppressable info message. This allows the CDK users to suppress the unnecessary info annotation message.
> 
> I propose adding addInfoV2() -- the Info-level counterpart to addWarningV2() -- which would let builders acknowledge an Info message once and prevent it from re-appearing in subsequent runs.

### Description of changes

This PR adds the following new features to the `Annotations` class:

1. `addInfoV2` method - A method to add acknowledgeable info messages
2. `acknowledgeInfo` method - A method to mark specific info messages as acknowledged

These changes follow the same pattern as the existing warning message functionality (`addWarningV2`/`acknowledgeWarning`), maintaining API consistency.

### Describe any new or updated permissions being added

This PR does not add any new IAM permissions.

### Description of how you validated changes

The following tests were added to validate the functionality:

1. Tests confirming that `addInfoV2` correctly adds info messages
2. Tests verifying that `acknowledgeInfo` correctly marks info messages as acknowledged and they are no longer displayed

### Checklist
- [x] My code adheres to the [CONTRIBUTING GUIDE](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md) and [DESIGN GUIDELINES](https://github.com/aws/aws-cdk/blob/main/docs/DESIGN_GUIDELINES.md)

----

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: hassaku63

packages/aws-cdk-lib/core/README.md

@@ -1800,6 +1800,17 @@ warning by the `id`.
 Annotations.of(this).acknowledgeWarning('IAM:Group:MaxPoliciesExceeded', 'Account has quota increased to 20');
 ```
 
+### Acknowledging Infos
+
+Informational messages can also be emitted and acknowledged. Use `addInfoV2()`
+to add an info message that can later be suppressed with `acknowledgeInfo()`.
+Unlike warnings, info messages are not affected by the `--strict` mode and will never cause synthesis to fail.
+
+```ts
+Annotations.of(this).addInfoV2('my-lib:Construct.someInfo', 'Some message explaining the info');
+Annotations.of(this).acknowledgeInfo('my-lib:Construct.someInfo', 'This info can be ignored');
+```
+
 ## RemovalPolicies
 
 The `RemovalPolicies` class provides a convenient way to manage removal policies for AWS CDK resources within a construct scope. It allows you to apply removal policies to multiple resources at once, with options to include or exclude specific resource types.

packages/aws-cdk-lib/core/lib/annotations.ts

@@ -89,6 +89,51 @@ export class Annotations {
     this.addMessage(cxschema.ArtifactMetadataEntryType.WARN, message);
   }
 
+  /**
+   * Acknowledge a info. When a info is acknowledged for a scope
+   * all infos that match the id will be ignored.
+   *
+   * The acknowledgement will apply to all child scopes
+   *
+   * @example
+   * declare const myConstruct: Construct;
+   * Annotations.of(myConstruct).acknowledgeInfo('SomeInfoId', 'This info can be ignored because...');
+   *
+   * @param id - the id of the info message to acknowledge
+   * @param message optional message to explain the reason for acknowledgement
+   */
+  public acknowledgeInfo(id: string, message?: string): void {
+    Acknowledgements.of(this.scope).add(this.scope, id);
+
+    // We don't use message currently, but encouraging people to supply it is good for documentation
+    // purposes, and we can always add a report on it in the future.
+    void(message);
+
+    // Iterate over the construct and remove any existing instances of this info
+    // (addInfoV2 will prevent future instances of it)
+    removeInfoDeep(this.scope, id);
+  }
+
+  /**
+   * Adds an acknowledgeable info metadata entry to this construct.
+   *
+   * The CLI will display the info when an app is synthesized.
+   *
+   * If the info is acknowledged using `acknowledgeInfo()`, it will not be shown by the CLI.
+   *
+   * @example
+   * declare const myConstruct: Construct;
+   * Annotations.of(myConstruct).addInfoV2('my-library:Construct.someInfo', 'Some message explaining the info');
+   *
+   * @param id the unique identifier for the info. This can be used to acknowledge the info
+   * @param message The info message.
+   */
+  public addInfoV2(id: string, message: string) {
+    if (!Acknowledgements.of(this.scope).has(this.scope, id)) {
+      this.addMessage(cxschema.ArtifactMetadataEntryType.INFO, `${message} ${ackTag(id)}`);
+    }
+  }
+
   /**
    * Adds an info metadata entry to this construct.
    *
@@ -259,6 +304,42 @@ function removeWarning(construct: IConstruct, id: string) {
   }
 }
 
+/**
+ * Remove info metadata from all constructs in a given scope
+ *
+ * No recursion to avoid blowing out the stack.
+ */
+function removeInfoDeep(construct: IConstruct, id: string) {
+  const stack = [construct];
+
+  while (stack.length > 0) {
+    const next = stack.pop()!;
+    removeInfo(next, id);
+    stack.push(...next.node.children);
+  }
+}
+
+/**
+ * Remove metadata from a construct node.
+ *
+ * This uses private APIs for now; we could consider adding this functionality
+ * to the constructs library itself.
+ */
+function removeInfo(construct: IConstruct, id: string) {
+  const meta: MetadataEntry[] | undefined = (construct.node as any)._metadata;
+  if (!meta) { return; }
+
+  let i = 0;
+  while (i < meta.length) {
+    const m = meta[i];
+    if (m.type === cxschema.ArtifactMetadataEntryType.INFO && (m.data as string).includes(ackTag(id))) {
+      meta.splice(i, 1);
+    } else {
+      i += 1;
+    }
+  }
+}
+
 function ackTag(id: string) {
   return `[ack: ${id}]`;
 }

packages/aws-cdk-lib/core/test/annotations.test.ts

@@ -1,5 +1,5 @@
 import { Construct } from 'constructs';
-import { getWarnings } from './util';
+import { getWarnings, getInfos } from './util';
 import { App, Stack } from '../lib';
 import { Annotations } from '../lib/annotations';
 
@@ -147,4 +147,101 @@ describe('annotations', () => {
       },
     ]);
   });
+
+  test('addInfoV2 adds an acknowledgeable info message', () => {
+    const app = new App();
+    const stack = new Stack(app, 'S1');
+    const c1 = new Construct(stack, 'C1');
+    Annotations.of(c1).addInfoV2('info1', 'This is an info message');
+    Annotations.of(c1).addInfoV2('info1', 'This is an info message');
+    Annotations.of(c1).addInfoV2('info1', 'This is an info message');
+    Annotations.of(c1).addInfoV2('info2', 'This is another info message');
+    expect(getInfos(app.synth())).toEqual([
+      {
+        path: '/S1/C1',
+        message: 'This is an info message [ack: info1]',
+      },
+      {
+        path: '/S1/C1',
+        message: 'This is another info message [ack: info2]',
+      },
+    ]);
+  });
+
+  test('acknowledgeInfo removes info message', () => {
+    // GIVEN
+    const app = new App();
+    const stack = new Stack(app, 'S1');
+    const c1 = new Construct(stack, 'C1');
+
+    // WHEN
+    Annotations.of(c1).addInfoV2('INFO1', 'This is an info message');
+    Annotations.of(c1).addInfoV2('INFO2', 'This is another info message');
+    Annotations.of(c1).acknowledgeInfo('INFO2', 'I acknowledge this info');
+
+    // THEN
+    expect(getInfos(app.synth())).toEqual([
+      {
+        path: '/S1/C1',
+        message: 'This is an info message [ack: INFO1]',
+      },
+    ]);
+  });
+
+  test('acknowledgeInfo removes info message on children', () => {
+    // GIVEN
+    const app = new App();
+    const stack = new Stack(app, 'S1');
+    const c1 = new Construct(stack, 'C1');
+    const c2 = new Construct(c1, 'C2');
+
+    // WHEN
+    Annotations.of(c2).addInfoV2('INFO2', 'This is an info message for child');
+    Annotations.of(c1).acknowledgeInfo('INFO2', 'I acknowledge this info');
+
+    // THEN
+    expect(getInfos(app.synth())).toEqual([]);
+  });
+
+  test('don\'t resolve the info message if tokens are included', () => {
+    // GIVEN
+    const app = new App();
+    const stack = new Stack(app, 'S1');
+    const c1 = new Construct(stack, 'C1');
+
+    // WHEN
+    Annotations.of(c1).addInfoV2('INFO', `stackId: ${stack.stackId}`);
+
+    // THEN
+    expect(getInfos(app.synth())).toEqual([
+      {
+        path: '/S1/C1',
+        message: expect.stringMatching(/stackId: \${Token\[AWS::StackId\.\d+\]} \[ack: INFO\]/),
+      },
+    ]);
+  });
+
+  test('messages with same ID are treated separately across different levels', () => {
+    const app = new App();
+    const stack = new Stack(app, 'S1');
+    const c1 = new Construct(stack, 'C1');
+
+    // WHEN
+    Annotations.of(c1).addWarningV2('message1', 'This is a message');
+    Annotations.of(c1).addInfoV2('message1', 'This is another message');
+
+    // THEN
+    expect(getWarnings(app.synth())).toEqual([
+      {
+        path: '/S1/C1',
+        message: 'This is a message [ack: message1]',
+      },
+    ]);
+    expect(getInfos(app.synth())).toEqual([
+      {
+        path: '/S1/C1',
+        message: 'This is another message [ack: message1]',
+      },
+    ]);
+  });
 });

packages/aws-cdk-lib/core/test/util.ts

@@ -44,3 +44,16 @@ export function getWarnings(casm: CloudAssembly) {
   }
   return result;
 }
+
+export function getInfos(casm: CloudAssembly) {
+  const result = new Array<{ path: string; message: string }>();
+  for (const stack of Object.values(casm.manifest.artifacts ?? {})) {
+    const artifact = CloudArtifact.fromManifest(casm, 'art', stack);
+    artifact?.messages.forEach(message => {
+      if (message.level === SynthesisMessageLevel.INFO) {
+        result.push({ path: message.id, message: message.entry.data as string });
+      }
+    });
+  }
+  return result;
+}