@aws-cdk/toolkit-lib 0.3.1 → 0.3.3

package/lib/api/io/private/span.d.ts

@@ -0,0 +1,93 @@
+import type { ActionLessMessage, IoHelper } from './io-helper';
+import type { IoMessageMaker } from './message-maker';
+import type { Duration } from '../../../payloads/types';
+export interface SpanEnd {
+    readonly duration: number;
+}
+/**
+ * Describes a specific span
+ *
+ * A span definition is a pair of `IoMessageMaker`s to create a start and end message of the span respectively.
+ * It also has a display name, that is used for auto-generated message text when they are not provided.
+ */
+export interface SpanDefinition<S extends object, E extends SpanEnd> {
+    readonly name: string;
+    readonly start: IoMessageMaker<S>;
+    readonly end: IoMessageMaker<E>;
+}
+/**
+ * Used in conditional types to check if a type (e.g. after omitting fields) is an empty object
+ * This is needed because counter-intuitive neither `object` nor `{}` represent that.
+ */
+type EmptyObject = {
+    [index: string | number | symbol]: never;
+};
+/**
+ * Helper type to force a parameter to be not present of the computed type is an empty object
+ */
+type VoidWhenEmpty<T> = T extends EmptyObject ? void : T;
+/**
+ * Helper type to force a parameter to be an empty object if the computed type is an empty object
+ * This is weird, but some computed types (e.g. using `Omit`) don't end up enforcing this.
+ */
+type ForceEmpty<T> = T extends EmptyObject ? EmptyObject : T;
+/**
+ * Make some properties optional
+ */
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+/**
+ * Ending the span returns the observed duration
+ */
+interface ElapsedTime {
+    readonly asMs: number;
+    readonly asSec: number;
+}
+/**
+ * A message span that can be ended and read times from
+ */
+export interface IMessageSpan<E extends SpanEnd> {
+    /**
+     * Get the time elapsed since the start
+     */
+    elapsedTime(): Promise<ElapsedTime>;
+    /**
+     * Sends a simple, generic message with the current timing
+     * For more complex intermediate messages, get the `elapsedTime` and use `notify`
+     */
+    timing(maker: IoMessageMaker<Duration>, message?: string): Promise<ElapsedTime>;
+    /**
+     * Sends an arbitrary intermediate message as part of the span
+     */
+    notify(message: ActionLessMessage<unknown>): Promise<void>;
+    /**
+     * End the span with a payload
+     */
+    end(payload: VoidWhenEmpty<Omit<E, keyof SpanEnd>>): Promise<ElapsedTime>;
+    /**
+     * End the span with a payload, overwriting
+     */
+    end(payload: VoidWhenEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime>;
+    /**
+     * End the span with a message and payload
+     */
+    end(message: string, payload: ForceEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime>;
+}
+/**
+ * Helper class to make spans around blocks of work
+ *
+ * Blocks are enclosed by a start and end message.
+ * All messages of the span share a unique id.
+ * The end message contains the time passed between start and end.
+ */
+export declare class SpanMaker<S extends object, E extends SpanEnd> {
+    private readonly definition;
+    private readonly ioHelper;
+    constructor(ioHelper: IoHelper, definition: SpanDefinition<S, E>);
+    /**
+     * Starts the span and initially notifies the IoHost
+     * @returns a message span
+     */
+    begin(payload: VoidWhenEmpty<S>): Promise<IMessageSpan<E>>;
+    begin(message: string, payload: S): Promise<IMessageSpan<E>>;
+}
+export {};

package/lib/api/io/private/span.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpanMaker = void 0;
+const util = require("node:util");
+const uuid = require("uuid");
+const util_1 = require("../../../util");
+/**
+ * Helper class to make spans around blocks of work
+ *
+ * Blocks are enclosed by a start and end message.
+ * All messages of the span share a unique id.
+ * The end message contains the time passed between start and end.
+ */
+class SpanMaker {
+    definition;
+    ioHelper;
+    constructor(ioHelper, definition) {
+        this.definition = definition;
+        this.ioHelper = ioHelper;
+    }
+    async begin(a, b) {
+        const spanId = uuid.v4();
+        const startTime = new Date().getTime();
+        const notify = (msg) => {
+            return this.ioHelper.notify(withSpanId(spanId, msg));
+        };
+        const startInput = parseArgs(a, b);
+        const startMsg = startInput.message ?? `Starting ${this.definition.name} ...`;
+        const startPayload = startInput.payload;
+        await notify(this.definition.start.msg(startMsg, startPayload));
+        const timingMsgTemplate = '\n✨  %s time: %ds\n';
+        const time = () => {
+            const elapsedTime = new Date().getTime() - startTime;
+            return {
+                asMs: elapsedTime,
+                asSec: (0, util_1.formatTime)(elapsedTime),
+            };
+        };
+        return {
+            elapsedTime: async () => {
+                return time();
+            },
+            notify: async (msg) => {
+                await notify(msg);
+            },
+            timing: async (maker, message) => {
+                const duration = time();
+                const timingMsg = message ? message : util.format(timingMsgTemplate, this.definition.name, duration.asSec);
+                await notify(maker.msg(timingMsg, {
+                    duration: duration.asMs,
+                }));
+                return duration;
+            },
+            end: async (x, y) => {
+                const duration = time();
+                const endInput = parseArgs(x, y);
+                const endMsg = endInput.message ?? util.format(timingMsgTemplate, this.definition.name, duration.asSec);
+                const endPayload = endInput.payload;
+                await notify(this.definition.end.msg(endMsg, {
+                    duration: duration.asMs,
+                    ...endPayload,
+                }));
+                return duration;
+            },
+        };
+    }
+}
+exports.SpanMaker = SpanMaker;
+function parseArgs(first, second) {
+    const firstIsMessage = typeof first === 'string';
+    // When the first argument is a string or we have a second argument, then the first arg is the message
+    const message = (firstIsMessage || second) ? first : undefined;
+    // When the first argument is a string or we have a second argument,
+    // then the second arg is the payload, otherwise the first arg is the payload
+    const payload = (firstIsMessage || second) ? second : first;
+    return {
+        message,
+        payload,
+    };
+}
+function withSpanId(span, message) {
+    return {
+        ...message,
+        span,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"span.js","sourceRoot":"","sources":["span.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'node:util';\nimport * as uuid from 'uuid';\nimport type { ActionLessMessage, IoHelper } from './io-helper';\nimport type { IoMessageMaker } from './message-maker';\nimport type { Duration } from '../../../payloads/types';\nimport { formatTime } from '../../../util';\n\nexport interface SpanEnd {\n  readonly duration: number;\n}\n\n/**\n * Describes a specific span\n *\n * A span definition is a pair of `IoMessageMaker`s to create a start and end message of the span respectively.\n * It also has a display name, that is used for auto-generated message text when they are not provided.\n */\nexport interface SpanDefinition<S extends object, E extends SpanEnd> {\n  readonly name: string;\n  readonly start: IoMessageMaker<S>;\n  readonly end: IoMessageMaker<E>;\n}\n\n/**\n * Used in conditional types to check if a type (e.g. after omitting fields) is an empty object\n * This is needed because counter-intuitive neither `object` nor `{}` represent that.\n */\ntype EmptyObject = {\n  [index: string | number | symbol]: never;\n}\n\n/**\n * Helper type to force a parameter to be not present of the computed type is an empty object\n */\ntype VoidWhenEmpty<T> = T extends EmptyObject ? void : T\n\n/**\n * Helper type to force a parameter to be an empty object if the computed type is an empty object\n * This is weird, but some computed types (e.g. using `Omit`) don't end up enforcing this.\n */\ntype ForceEmpty<T> = T extends EmptyObject ? EmptyObject : T\n\n/**\n * Make some properties optional\n */\ntype Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;\n\n/**\n * Ending the span returns the observed duration\n */\ninterface ElapsedTime {\n  readonly asMs: number;\n  readonly asSec: number;\n}\n\n/**\n * A message span that can be ended and read times from\n */\nexport interface IMessageSpan<E extends SpanEnd> {\n  /**\n   * Get the time elapsed since the start\n   */\n  elapsedTime(): Promise<ElapsedTime>;\n  /**\n   * Sends a simple, generic message with the current timing\n   * For more complex intermediate messages, get the `elapsedTime` and use `notify`\n   */\n  timing(maker: IoMessageMaker<Duration>, message?: string): Promise<ElapsedTime>;\n  /**\n   * Sends an arbitrary intermediate message as part of the span\n   */\n  notify(message: ActionLessMessage<unknown>): Promise<void>;\n  /**\n   * End the span with a payload\n   */\n  end(payload: VoidWhenEmpty<Omit<E, keyof SpanEnd>>): Promise<ElapsedTime>;\n  /**\n   * End the span with a payload, overwriting\n   */\n  end(payload: VoidWhenEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime>;\n  /**\n   * End the span with a message and payload\n   */\n  end(message: string, payload: ForceEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime>;\n}\n\n/**\n * Helper class to make spans around blocks of work\n *\n * Blocks are enclosed by a start and end message.\n * All messages of the span share a unique id.\n * The end message contains the time passed between start and end.\n */\nexport class SpanMaker<S extends object, E extends SpanEnd> {\n  private readonly definition: SpanDefinition<S, E>;\n  private readonly ioHelper: IoHelper;\n\n  public constructor(ioHelper: IoHelper, definition: SpanDefinition<S, E>) {\n    this.definition = definition;\n    this.ioHelper = ioHelper;\n  }\n\n  /**\n   * Starts the span and initially notifies the IoHost\n   * @returns a message span\n   */\n  public async begin(payload: VoidWhenEmpty<S>): Promise<IMessageSpan<E>>;\n  public async begin(message: string, payload: S): Promise<IMessageSpan<E>>;\n  public async begin(a: any, b?: S): Promise<IMessageSpan<E>> {\n    const spanId = uuid.v4();\n    const startTime = new Date().getTime();\n\n    const notify = (msg: ActionLessMessage<unknown>): Promise<void> => {\n      return this.ioHelper.notify(withSpanId(spanId, msg));\n    };\n\n    const startInput = parseArgs<S>(a, b);\n    const startMsg = startInput.message ?? `Starting ${this.definition.name} ...`;\n    const startPayload = startInput.payload;\n\n    await notify(this.definition.start.msg(\n      startMsg,\n      startPayload,\n    ));\n\n    const timingMsgTemplate = '\\n✨  %s time: %ds\\n';\n    const time = () => {\n      const elapsedTime = new Date().getTime() - startTime;\n      return {\n        asMs: elapsedTime,\n        asSec: formatTime(elapsedTime),\n      };\n    };\n\n    return {\n      elapsedTime: async (): Promise<ElapsedTime> => {\n        return time();\n      },\n\n      notify: async(msg: ActionLessMessage<unknown>): Promise<void> => {\n        await notify(msg);\n      },\n\n      timing: async(maker: IoMessageMaker<Duration>, message?: string): Promise<ElapsedTime> => {\n        const duration = time();\n        const timingMsg = message ? message : util.format(timingMsgTemplate, this.definition.name, duration.asSec);\n        await notify(maker.msg(timingMsg, {\n          duration: duration.asMs,\n        }));\n        return duration;\n      },\n\n      end: async (x: any, y?: ForceEmpty<Optional<E, keyof SpanEnd>>): Promise<ElapsedTime> => {\n        const duration = time();\n\n        const endInput = parseArgs<ForceEmpty<Optional<E, keyof SpanEnd>>>(x, y);\n        const endMsg = endInput.message ?? util.format(timingMsgTemplate, this.definition.name, duration.asSec);\n        const endPayload = endInput.payload;\n\n        await notify(this.definition.end.msg(\n          endMsg, {\n            duration: duration.asMs,\n            ...endPayload,\n          } as E));\n\n        return duration;\n      },\n    };\n  }\n}\n\nfunction parseArgs<S extends object>(first: any, second?: S): { message: string | undefined; payload: S } {\n  const firstIsMessage = typeof first === 'string';\n\n  // When the first argument is a string or we have a second argument, then the first arg is the message\n  const message = (firstIsMessage || second) ? first : undefined;\n\n  // When the first argument is a string or we have a second argument,\n  // then the second arg is the payload, otherwise the first arg is the payload\n  const payload = (firstIsMessage || second) ? second : first;\n\n  return {\n    message,\n    payload,\n  };\n}\n\nfunction withSpanId(span: string, message: ActionLessMessage<unknown>): ActionLessMessage<unknown> {\n  return {\n    ...message,\n    span,\n  };\n}\n"]}

package/lib/api/io/private/testing/fake-io-host.d.ts

@@ -0,0 +1,28 @@
+import type { IIoHost } from '../../io-host';
+import type { IoMessage, IoMessageLevel, IoRequest } from '../../io-message';
+/**
+ * An implementation of `IIoHost` that records messages and lets you assert on what was logged
+ *
+ * It's like `TestIoHost`, but comes with a predefined implementation for `notify`
+ * that appends all messages to an in-memory array, and comes with a helper function
+ * `expectMessage()` to test for the existence of a function in that array.
+ *
+ * Has a public mock for `requestResponse` that you configure like any
+ * other mock function.
+ *
+ * # How to use
+ *
+ * Either create a new instance of this class for every test, or call `clear()`
+ * on it between runs.
+ */
+export declare class FakeIoHost implements IIoHost {
+    messages: Array<IoMessage<unknown>>;
+    requestResponse: <T, U>(msg: IoRequest<T, U>) => Promise<U>;
+    constructor();
+    clear(): void;
+    notify(msg: IoMessage<unknown>): Promise<void>;
+    expectMessage(m: {
+        containing: string;
+        level?: IoMessageLevel;
+    }): void;
+}

package/lib/api/io/private/testing/fake-io-host.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeIoHost = void 0;
+/**
+ * An implementation of `IIoHost` that records messages and lets you assert on what was logged
+ *
+ * It's like `TestIoHost`, but comes with a predefined implementation for `notify`
+ * that appends all messages to an in-memory array, and comes with a helper function
+ * `expectMessage()` to test for the existence of a function in that array.
+ *
+ * Has a public mock for `requestResponse` that you configure like any
+ * other mock function.
+ *
+ * # How to use
+ *
+ * Either create a new instance of this class for every test, or call `clear()`
+ * on it between runs.
+ */
+class FakeIoHost {
+    messages = [];
+    requestResponse;
+    constructor() {
+        this.clear();
+    }
+    clear() {
+        this.messages.splice(0, this.messages.length);
+        this.requestResponse = jest.fn().mockRejectedValue(new Error('requestResponse not mocked'));
+    }
+    async notify(msg) {
+        this.messages.push(msg);
+    }
+    expectMessage(m) {
+        expect(this.messages).toContainEqual(expect.objectContaining({
+            ...m.level ? { level: m.level } : undefined,
+            // Can be a partial string as well
+            message: expect.stringContaining(m.containing),
+        }));
+    }
+}
+exports.FakeIoHost = FakeIoHost;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/io/private/testing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './test-io-host';
+export * from './fake-io-host';

package/lib/api/io/private/testing/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./test-io-host"), exports);
+__exportStar(require("./fake-io-host"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaURBQStCO0FBQy9CLGlEQUErQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGVzdC1pby1ob3N0JztcbmV4cG9ydCAqIGZyb20gJy4vZmFrZS1pby1ob3N0JztcbiJdfQ==

package/lib/api/io/private/testing/test-io-host.d.ts

@@ -0,0 +1,27 @@
+import { RequireApproval } from '../../../require-approval';
+import type { IIoHost } from '../../io-host';
+import type { IoMessage, IoMessageLevel, IoRequest } from '../../io-message';
+import type { IoHelper } from '../io-helper';
+/**
+ * A test implementation of IIoHost that does nothing but can be spied on.
+ *
+ * Includes a level to filter out irrelevant messages, defaults to `info`.
+ *
+ * Optionally set an approval level for code `CDK_TOOLKIT_I5060`.
+ *
+ * # How to use
+ *
+ * Configure and reset the `notifySpy` and `requestSpy` members as you would any
+ * mock function.
+ */
+export declare class TestIoHost implements IIoHost {
+    level: IoMessageLevel;
+    readonly notifySpy: jest.Mock<any, any, any>;
+    readonly requestSpy: jest.Mock<any, any, any>;
+    requireDeployApproval: RequireApproval;
+    constructor(level?: IoMessageLevel);
+    asHelper(action?: string): IoHelper;
+    notify(msg: IoMessage<unknown>): Promise<void>;
+    requestResponse<T, U>(msg: IoRequest<T, U>): Promise<U>;
+    private needsApproval;
+}

package/lib/api/io/private/testing/test-io-host.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestIoHost = void 0;
+const require_approval_1 = require("../../../require-approval");
+const io_helper_1 = require("../io-helper");
+const level_priority_1 = require("../level-priority");
+/**
+ * A test implementation of IIoHost that does nothing but can be spied on.
+ *
+ * Includes a level to filter out irrelevant messages, defaults to `info`.
+ *
+ * Optionally set an approval level for code `CDK_TOOLKIT_I5060`.
+ *
+ * # How to use
+ *
+ * Configure and reset the `notifySpy` and `requestSpy` members as you would any
+ * mock function.
+ */
+class TestIoHost {
+    level;
+    notifySpy;
+    requestSpy;
+    requireDeployApproval = require_approval_1.RequireApproval.NEVER;
+    constructor(level = 'info') {
+        this.level = level;
+        this.notifySpy = jest.fn();
+        this.requestSpy = jest.fn();
+    }
+    asHelper(action = 'synth') {
+        return (0, io_helper_1.asIoHelper)(this, action);
+    }
+    async notify(msg) {
+        if ((0, level_priority_1.isMessageRelevantForLevel)(msg, this.level)) {
+            this.notifySpy(msg);
+        }
+    }
+    async requestResponse(msg) {
+        if ((0, level_priority_1.isMessageRelevantForLevel)(msg, this.level) && this.needsApproval(msg)) {
+            this.requestSpy(msg);
+        }
+        return msg.defaultResponse;
+    }
+    needsApproval(msg) {
+        // Return true if the code is unrelated to approval
+        if (!['CDK_TOOLKIT_I5060'].includes(msg.code)) {
+            return true;
+        }
+        switch (this.requireDeployApproval) {
+            case require_approval_1.RequireApproval.NEVER:
+                return false;
+            case require_approval_1.RequireApproval.ANY_CHANGE:
+                return true;
+            case require_approval_1.RequireApproval.BROADENING:
+                return msg.data?.permissionChangeType === 'broadening';
+            default:
+                return true;
+        }
+    }
+}
+exports.TestIoHost = TestIoHost;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/io/private/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Valid reporting categories for messages.
+ */
+export type IoMessageCodeCategory = 'TOOLKIT' | 'SDK' | 'ASSETS' | 'ASSEMBLY';

package/lib/api/io/private/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBWYWxpZCByZXBvcnRpbmcgY2F0ZWdvcmllcyBmb3IgbWVzc2FnZXMuXG4gKi9cbmV4cG9ydCB0eXBlIElvTWVzc2FnZUNvZGVDYXRlZ29yeSA9ICdUT09MS0lUJyB8ICdTREsnIHwgJ0FTU0VUUycgfCAnQVNTRU1CTFknO1xuIl19

package/lib/api/io/toolkit-action.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The current action being performed by the CLI. 'none' represents the absence of an action.
+ */
+export type ToolkitAction = 'assembly' | 'bootstrap' | 'synth' | 'list' | 'diff' | 'deploy' | 'rollback' | 'watch' | 'destroy' | 'doctor' | 'gc' | 'import' | 'metadata' | 'init' | 'migrate' | 'refactor';

package/lib/api/io/toolkit-action.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbGtpdC1hY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0b29sa2l0LWFjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgY3VycmVudCBhY3Rpb24gYmVpbmcgcGVyZm9ybWVkIGJ5IHRoZSBDTEkuICdub25lJyByZXByZXNlbnRzIHRoZSBhYnNlbmNlIG9mIGFuIGFjdGlvbi5cbiAqL1xuZXhwb3J0IHR5cGUgVG9vbGtpdEFjdGlvbiA9XG58ICdhc3NlbWJseSdcbnwgJ2Jvb3RzdHJhcCdcbnwgJ3N5bnRoJ1xufCAnbGlzdCdcbnwgJ2RpZmYnXG58ICdkZXBsb3knXG58ICdyb2xsYmFjaydcbnwgJ3dhdGNoJ1xufCAnZGVzdHJveSdcbnwgJ2RvY3RvcidcbnwgJ2djJ1xufCAnaW1wb3J0J1xufCAnbWV0YWRhdGEnXG58ICdpbml0J1xufCAnbWlncmF0ZSdcbnwgJ3JlZmFjdG9yJztcbiJdfQ==

package/lib/api/logs-monitor/find-cloudwatch-logs.d.ts

@@ -0,0 +1,25 @@
+import type { CloudFormationStackArtifact, Environment } from '@aws-cdk/cx-api';
+import type { SDK, SdkProvider } from '../aws-auth/private';
+import type { IoHelper } from '../io/private';
+/**
+ * Configuration needed to monitor CloudWatch Log Groups
+ * found in a given CloudFormation Stack
+ */
+export interface FoundLogGroupsResult {
+    /**
+     * The resolved environment (account/region) that the log
+     * groups are deployed in
+     */
+    readonly env: Environment;
+    /**
+     * The SDK that can be used to read events from the CloudWatch
+     * Log Groups in the given environment
+     */
+    readonly sdk: SDK;
+    /**
+     * The names of the relevant CloudWatch Log Groups
+     * in the given CloudFormation template
+     */
+    readonly logGroupNames: string[];
+}
+export declare function findCloudWatchLogGroups(sdkProvider: SdkProvider, ioHelper: IoHelper, stackArtifact: CloudFormationStackArtifact): Promise<FoundLogGroupsResult>;

package/lib/api/logs-monitor/find-cloudwatch-logs.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCloudWatchLogGroups = findCloudWatchLogGroups;
+const util_1 = require("../../util");
+const cloudformation_1 = require("../cloudformation");
+const environment_1 = require("../environment");
+const private_1 = require("../io/private");
+const plugin_1 = require("../plugin");
+const toolkit_info_1 = require("../toolkit-info");
+// resource types that have associated CloudWatch Log Groups that should _not_ be monitored
+const IGNORE_LOGS_RESOURCE_TYPES = ['AWS::EC2::FlowLog', 'AWS::CloudTrail::Trail', 'AWS::CodeBuild::Project'];
+async function findCloudWatchLogGroups(sdkProvider, ioHelper, stackArtifact) {
+    let sdk;
+    const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
+    // try to assume the lookup role and fallback to the default credentials
+    try {
+        sdk = (await new environment_1.EnvironmentAccess(sdkProvider, toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME, ioHelper).accessStackForLookup(stackArtifact)).sdk;
+    }
+    catch (e) {
+        await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Failed to access SDK environment: ${(0, util_1.formatErrorMessage)(e)}`));
+        sdk = (await sdkProvider.forEnvironment(resolvedEnv, plugin_1.Mode.ForReading)).sdk;
+    }
+    const listStackResources = new cloudformation_1.LazyListStackResources(sdk, stackArtifact.stackName);
+    const evaluateCfnTemplate = new cloudformation_1.EvaluateCloudFormationTemplate({
+        stackArtifact,
+        parameters: {},
+        account: resolvedEnv.account,
+        region: resolvedEnv.region,
+        partition: (await sdk.currentAccount()).partition,
+        sdk,
+    });
+    const stackResources = await listStackResources.listStackResources();
+    const logGroupNames = findAllLogGroupNames(stackResources, evaluateCfnTemplate);
+    return {
+        env: resolvedEnv,
+        sdk,
+        logGroupNames,
+    };
+}
+/**
+ * Determine if a CloudWatch Log Group is associated
+ * with an ignored resource
+ */
+function isReferencedFromIgnoredResource(logGroupResource, evaluateCfnTemplate) {
+    const resourcesReferencingLogGroup = evaluateCfnTemplate.findReferencesTo(logGroupResource.LogicalResourceId);
+    return resourcesReferencingLogGroup.some((reference) => {
+        return IGNORE_LOGS_RESOURCE_TYPES.includes(reference.Type);
+    });
+}
+const cloudWatchLogsResolvers = {
+    'AWS::Logs::LogGroup': (resource, evaluateCfnTemplate) => {
+        if (isReferencedFromIgnoredResource(resource, evaluateCfnTemplate)) {
+            return undefined;
+        }
+        return resource.PhysicalResourceId?.toString();
+    },
+    // Resource types that will create a CloudWatch log group with a specific name if one is not provided.
+    // The keys are CFN resource types, and the values are the name of the physical name property of that resource
+    // and the service name that is used in the automatically created CloudWatch log group.
+    'AWS::Lambda::Function': (resource, evaluateCfnTemplate) => {
+        const loggingConfig = evaluateCfnTemplate.getResourceProperty(resource.LogicalResourceId, 'LoggingConfig');
+        if (loggingConfig?.LogGroup) {
+            // if LogGroup is a string then use it as the LogGroupName as it is referred by LogGroup.fromLogGroupArn in CDK
+            if (typeof loggingConfig.LogGroup === 'string') {
+                return loggingConfig.LogGroup;
+            }
+            // if { Ref: '...' } is used then try to resolve the LogGroupName from the referenced resource in the template
+            if (typeof loggingConfig.LogGroup === 'object') {
+                if (loggingConfig.LogGroup.Ref) {
+                    return evaluateCfnTemplate.getResourceProperty(loggingConfig.LogGroup.Ref, 'LogGroupName');
+                }
+            }
+        }
+        return `/aws/lambda/${resource.PhysicalResourceId}`;
+    },
+};
+/**
+ * Find all CloudWatch Log Groups in the deployed template.
+ * This will find both explicitly created Log Groups (excluding those associated with ignored resources)
+ * and Log Groups created implicitly (i.e. Lambda Functions)
+ */
+function findAllLogGroupNames(stackResources, evaluateCfnTemplate) {
+    const logGroupNames = [];
+    for (const resource of stackResources) {
+        const logGroupResolver = cloudWatchLogsResolvers[resource.ResourceType];
+        if (logGroupResolver) {
+            const logGroupName = logGroupResolver(resource, evaluateCfnTemplate);
+            if (logGroupName) {
+                logGroupNames.push(logGroupName);
+            }
+        }
+    }
+    return logGroupNames;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"find-cloudwatch-logs.js","sourceRoot":"","sources":["find-cloudwatch-logs.ts"],"names":[],"mappings":";;AAsCA,0DAiCC;AArED,qCAAgD;AAEhD,sDAA2F;AAC3F,gDAAmD;AACnD,2CAAmC;AAEnC,sCAAiC;AACjC,kDAA6D;AAE7D,2FAA2F;AAC3F,MAAM,0BAA0B,GAAG,CAAC,mBAAmB,EAAE,wBAAwB,EAAE,yBAAyB,CAAC,CAAC;AA0BvG,KAAK,UAAU,uBAAuB,CAC3C,WAAwB,EACxB,QAAkB,EAClB,aAA0C;IAE1C,IAAI,GAAQ,CAAC;IACb,MAAM,WAAW,GAAG,MAAM,WAAW,CAAC,kBAAkB,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;IACpF,wEAAwE;IACxE,IAAI,CAAC;QACH,GAAG,GAAG,CAAC,MAAM,IAAI,+BAAiB,CAAC,WAAW,EAAE,yCAA0B,EAAE,QAAQ,CAAC,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC;IACjI,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,MAAM,QAAQ,CAAC,MAAM,CAAC,YAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,qCAAqC,IAAA,yBAAkB,EAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAClH,GAAG,GAAG,CAAC,MAAM,WAAW,CAAC,cAAc,CAAC,WAAW,EAAE,aAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC;IAC7E,CAAC;IAED,MAAM,kBAAkB,GAAG,IAAI,uCAAsB,CAAC,GAAG,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IACpF,MAAM,mBAAmB,GAAG,IAAI,+CAA8B,CAAC;QAC7D,aAAa;QACb,UAAU,EAAE,EAAE;QACd,OAAO,EAAE,WAAW,CAAC,OAAO;QAC5B,MAAM,EAAE,WAAW,CAAC,MAAM;QAC1B,SAAS,EAAE,CAAC,MAAM,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC,SAAS;QACjD,GAAG;KACJ,CAAC,CAAC;IAEH,MAAM,cAAc,GAAG,MAAM,kBAAkB,CAAC,kBAAkB,EAAE,CAAC;IACrE,MAAM,aAAa,GAAG,oBAAoB,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;IAEhF,OAAO;QACL,GAAG,EAAE,WAAW;QAChB,GAAG;QACH,aAAa;KACd,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,+BAA+B,CACtC,gBAAsC,EACtC,mBAAmD;IAEnD,MAAM,4BAA4B,GAAG,mBAAmB,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,iBAAkB,CAAC,CAAC;IAC/G,OAAO,4BAA4B,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE;QACrD,OAAO,0BAA0B,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;AACL,CAAC;AAOD,MAAM,uBAAuB,GAA2C;IACtE,qBAAqB,EAAE,CAAC,QAAQ,EAAE,mBAAmB,EAAE,EAAE;QACvD,IAAI,+BAA+B,CAAC,QAAQ,EAAE,mBAAmB,CAAC,EAAE,CAAC;YACnE,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,QAAQ,CAAC,kBAAkB,EAAE,QAAQ,EAAE,CAAC;IACjD,CAAC;IAED,sGAAsG;IACtG,8GAA8G;IAC9G,uFAAuF;IACvF,uBAAuB,EAAE,CAAC,QAAQ,EAAE,mBAAmB,EAAE,EAAE;QACzD,MAAM,aAAa,GAAG,mBAAmB,CAAC,mBAAmB,CAAC,QAAQ,CAAC,iBAAkB,EAAE,eAAe,CAAC,CAAC;QAC5G,IAAI,aAAa,EAAE,QAAQ,EAAE,CAAC;YAC5B,+GAA+G;YAC/G,IAAI,OAAO,aAAa,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC/C,OAAO,aAAa,CAAC,QAAQ,CAAC;YAChC,CAAC;YAED,8GAA8G;YAC9G,IAAI,OAAO,aAAa,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC/C,IAAI,aAAa,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;oBAC/B,OAAO,mBAAmB,CAAC,mBAAmB,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;gBAC7F,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,eAAe,QAAQ,CAAC,kBAAkB,EAAE,CAAC;IACtD,CAAC;CACF,CAAC;AAEF;;;;GAIG;AACH,SAAS,oBAAoB,CAC3B,cAAsC,EACtC,mBAAmD;IAEnD,MAAM,aAAa,GAAa,EAAE,CAAC;IAEnC,KAAK,MAAM,QAAQ,IAAI,cAAc,EAAE,CAAC;QACtC,MAAM,gBAAgB,GAAG,uBAAuB,CAAC,QAAQ,CAAC,YAAa,CAAC,CAAC;QACzE,IAAI,gBAAgB,EAAE,CAAC;YACrB,MAAM,YAAY,GAAG,gBAAgB,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;YACrE,IAAI,YAAY,EAAE,CAAC;gBACjB,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACnC,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,aAAa,CAAC;AACvB,CAAC","sourcesContent":["import type { CloudFormationStackArtifact, Environment } from '@aws-cdk/cx-api';\nimport type { StackResourceSummary } from '@aws-sdk/client-cloudformation';\nimport { formatErrorMessage } from '../../util';\nimport type { SDK, SdkProvider } from '../aws-auth/private';\nimport { EvaluateCloudFormationTemplate, LazyListStackResources } from '../cloudformation';\nimport { EnvironmentAccess } from '../environment';\nimport { IO } from '../io/private';\nimport type { IoHelper } from '../io/private';\nimport { Mode } from '../plugin';\nimport { DEFAULT_TOOLKIT_STACK_NAME } from '../toolkit-info';\n\n// resource types that have associated CloudWatch Log Groups that should _not_ be monitored\nconst IGNORE_LOGS_RESOURCE_TYPES = ['AWS::EC2::FlowLog', 'AWS::CloudTrail::Trail', 'AWS::CodeBuild::Project'];\n\n/**\n * Configuration needed to monitor CloudWatch Log Groups\n * found in a given CloudFormation Stack\n */\nexport interface FoundLogGroupsResult {\n  /**\n   * The resolved environment (account/region) that the log\n   * groups are deployed in\n   */\n  readonly env: Environment;\n\n  /**\n   * The SDK that can be used to read events from the CloudWatch\n   * Log Groups in the given environment\n   */\n  readonly sdk: SDK;\n\n  /**\n   * The names of the relevant CloudWatch Log Groups\n   * in the given CloudFormation template\n   */\n  readonly logGroupNames: string[];\n}\n\nexport async function findCloudWatchLogGroups(\n  sdkProvider: SdkProvider,\n  ioHelper: IoHelper,\n  stackArtifact: CloudFormationStackArtifact,\n): Promise<FoundLogGroupsResult> {\n  let sdk: SDK;\n  const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);\n  // try to assume the lookup role and fallback to the default credentials\n  try {\n    sdk = (await new EnvironmentAccess(sdkProvider, DEFAULT_TOOLKIT_STACK_NAME, ioHelper).accessStackForLookup(stackArtifact)).sdk;\n  } catch (e: any) {\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Failed to access SDK environment: ${formatErrorMessage(e)}`));\n    sdk = (await sdkProvider.forEnvironment(resolvedEnv, Mode.ForReading)).sdk;\n  }\n\n  const listStackResources = new LazyListStackResources(sdk, stackArtifact.stackName);\n  const evaluateCfnTemplate = new EvaluateCloudFormationTemplate({\n    stackArtifact,\n    parameters: {},\n    account: resolvedEnv.account,\n    region: resolvedEnv.region,\n    partition: (await sdk.currentAccount()).partition,\n    sdk,\n  });\n\n  const stackResources = await listStackResources.listStackResources();\n  const logGroupNames = findAllLogGroupNames(stackResources, evaluateCfnTemplate);\n\n  return {\n    env: resolvedEnv,\n    sdk,\n    logGroupNames,\n  };\n}\n\n/**\n * Determine if a CloudWatch Log Group is associated\n * with an ignored resource\n */\nfunction isReferencedFromIgnoredResource(\n  logGroupResource: StackResourceSummary,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n): boolean {\n  const resourcesReferencingLogGroup = evaluateCfnTemplate.findReferencesTo(logGroupResource.LogicalResourceId!);\n  return resourcesReferencingLogGroup.some((reference) => {\n    return IGNORE_LOGS_RESOURCE_TYPES.includes(reference.Type);\n  });\n}\n\ntype CloudWatchLogsResolver = (\n  resource: StackResourceSummary,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n) => string | undefined;\n\nconst cloudWatchLogsResolvers: Record<string, CloudWatchLogsResolver> = {\n  'AWS::Logs::LogGroup': (resource, evaluateCfnTemplate) => {\n    if (isReferencedFromIgnoredResource(resource, evaluateCfnTemplate)) {\n      return undefined;\n    }\n    return resource.PhysicalResourceId?.toString();\n  },\n\n  // Resource types that will create a CloudWatch log group with a specific name if one is not provided.\n  // The keys are CFN resource types, and the values are the name of the physical name property of that resource\n  // and the service name that is used in the automatically created CloudWatch log group.\n  'AWS::Lambda::Function': (resource, evaluateCfnTemplate) => {\n    const loggingConfig = evaluateCfnTemplate.getResourceProperty(resource.LogicalResourceId!, 'LoggingConfig');\n    if (loggingConfig?.LogGroup) {\n      // if LogGroup is a string then use it as the LogGroupName as it is referred by LogGroup.fromLogGroupArn in CDK\n      if (typeof loggingConfig.LogGroup === 'string') {\n        return loggingConfig.LogGroup;\n      }\n\n      // if { Ref: '...' } is used then try to resolve the LogGroupName from the referenced resource in the template\n      if (typeof loggingConfig.LogGroup === 'object') {\n        if (loggingConfig.LogGroup.Ref) {\n          return evaluateCfnTemplate.getResourceProperty(loggingConfig.LogGroup.Ref, 'LogGroupName');\n        }\n      }\n    }\n\n    return `/aws/lambda/${resource.PhysicalResourceId}`;\n  },\n};\n\n/**\n * Find all CloudWatch Log Groups in the deployed template.\n * This will find both explicitly created Log Groups (excluding those associated with ignored resources)\n * and Log Groups created implicitly (i.e. Lambda Functions)\n */\nfunction findAllLogGroupNames(\n  stackResources: StackResourceSummary[],\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n): string[] {\n  const logGroupNames: string[] = [];\n\n  for (const resource of stackResources) {\n    const logGroupResolver = cloudWatchLogsResolvers[resource.ResourceType!];\n    if (logGroupResolver) {\n      const logGroupName = logGroupResolver(resource, evaluateCfnTemplate);\n      if (logGroupName) {\n        logGroupNames.push(logGroupName);\n      }\n    }\n  }\n\n  return logGroupNames;\n}\n"]}

package/lib/api/logs-monitor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logs-monitor';
+export * from './find-cloudwatch-logs';

package/lib/api/logs-monitor/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logs-monitor"), exports);
+__exportStar(require("./find-cloudwatch-logs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaURBQStCO0FBQy9CLHlEQUF1QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbG9ncy1tb25pdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vZmluZC1jbG91ZHdhdGNoLWxvZ3MnO1xuIl19