aws-cdk 0.0.0

package/lib/api/aws-auth/credential-plugins.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialPlugins = void 0;
+const util_1 = require("util");
+const provider_caching_1 = require("./provider-caching");
+const logging_1 = require("../../logging");
+const error_1 = require("../../toolkit/error");
+const error_2 = require("../../util/error");
+const plugin_1 = require("../plugin/plugin");
+/**
+ * Cache for credential providers.
+ *
+ * Given an account and an operating mode (read or write) will return an
+ * appropriate credential provider for credentials for the given account. The
+ * credential provider will be cached so that multiple AWS clients for the same
+ * environment will not make multiple network calls to obtain credentials.
+ *
+ * Will use default credentials if they are for the right account; otherwise,
+ * all loaded credential provider plugins will be tried to obtain credentials
+ * for the given account.
+ */
+class CredentialPlugins {
+    constructor(host) {
+        this.cache = {};
+        this.host = host !== null && host !== void 0 ? host : plugin_1.PluginHost.instance;
+    }
+    async fetchCredentialsFor(awsAccountId, mode) {
+        const key = `${awsAccountId}-${mode}`;
+        if (!(key in this.cache)) {
+            this.cache[key] = await this.lookupCredentials(awsAccountId, mode);
+        }
+        return this.cache[key];
+    }
+    get availablePluginNames() {
+        return this.host.credentialProviderSources.map((s) => s.name);
+    }
+    async lookupCredentials(awsAccountId, mode) {
+        const triedSources = [];
+        // Otherwise, inspect the various credential sources we have
+        for (const source of this.host.credentialProviderSources) {
+            let available;
+            try {
+                available = await source.isAvailable();
+            }
+            catch (e) {
+                // This shouldn't happen, but let's guard against it anyway
+                (0, logging_1.warning)(`Uncaught exception in ${source.name}: ${(0, error_2.formatErrorMessage)(e)}`);
+                available = false;
+            }
+            if (!available) {
+                (0, logging_1.debug)('Credentials source %s is not available, ignoring it.', source.name);
+                continue;
+            }
+            triedSources.push(source);
+            let canProvide;
+            try {
+                canProvide = await source.canProvideCredentials(awsAccountId);
+            }
+            catch (e) {
+                // This shouldn't happen, but let's guard against it anyway
+                (0, logging_1.warning)(`Uncaught exception in ${source.name}: ${(0, error_2.formatErrorMessage)(e)}`);
+                canProvide = false;
+            }
+            if (!canProvide) {
+                continue;
+            }
+            (0, logging_1.debug)(`Using ${source.name} credentials for account ${awsAccountId}`);
+            return {
+                credentials: await v3ProviderFromPlugin(() => source.getProvider(awsAccountId, mode, {
+                    supportsV3Providers: true,
+                })),
+                pluginName: source.name,
+            };
+        }
+        return undefined;
+    }
+}
+exports.CredentialPlugins = CredentialPlugins;
+/**
+ * Take a function that calls the plugin, and turn it into an SDKv3-compatible credential provider.
+ *
+ * What we will do is the following:
+ *
+ * - Query the plugin and see what kind of result it gives us.
+ * - If the result is self-refreshing or doesn't need refreshing, we turn it into an SDKv3 provider
+ *   and return it directly.
+ *   * If the underlying return value is a provider, we will make it a caching provider
+ *     (because we can't know if it will cache by itself or not).
+ *   * If the underlying return value is a static credential, caching isn't relevant.
+ *   * If the underlying return value is V2 credentials, those have caching built-in.
+ * - If the result is a static credential that expires, we will wrap it in an SDKv3 provider
+ *   that will query the plugin again when the credential expires.
+ */
+async function v3ProviderFromPlugin(producer) {
+    const initial = await producer();
+    if (isV3Provider(initial)) {
+        // Already a provider, make caching
+        return (0, provider_caching_1.makeCachingProvider)(initial);
+    }
+    else if (isV3Credentials(initial) && initial.expiration === undefined) {
+        // Static credentials that don't need refreshing nor caching
+        return () => Promise.resolve(initial);
+    }
+    else if (isV3Credentials(initial) && initial.expiration !== undefined) {
+        // Static credentials that do need refreshing and caching
+        return refreshFromPluginProvider(initial, producer);
+    }
+    else if (isV2Credentials(initial)) {
+        // V2 credentials that refresh and cache themselves
+        return v3ProviderFromV2Credentials(initial);
+    }
+    else {
+        throw new error_1.AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${(0, util_1.inspect)(initial)}`);
+    }
+}
+/**
+ * Converts a V2 credential into a V3-compatible provider
+ */
+function v3ProviderFromV2Credentials(x) {
+    return async () => {
+        var _a;
+        // Get will fetch or refresh as necessary
+        await x.getPromise();
+        return {
+            accessKeyId: x.accessKeyId,
+            secretAccessKey: x.secretAccessKey,
+            sessionToken: x.sessionToken,
+            expiration: (_a = x.expireTime) !== null && _a !== void 0 ? _a : undefined,
+        };
+    };
+}
+function refreshFromPluginProvider(current, producer) {
+    return async () => {
+        if ((0, provider_caching_1.credentialsAboutToExpire)(current)) {
+            const newCreds = await producer();
+            if (!isV3Credentials(newCreds)) {
+                throw new error_1.AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${(0, util_1.inspect)(newCreds)}`);
+            }
+            current = newCreds;
+        }
+        return current;
+    };
+}
+function isV3Provider(x) {
+    return typeof x === 'function';
+}
+function isV2Credentials(x) {
+    return !!(x && typeof x === 'object' && x.getPromise);
+}
+function isV3Credentials(x) {
+    return !!(x && typeof x === 'object' && x.accessKeyId && !isV2Credentials(x));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"credential-plugins.js","sourceRoot":"","sources":["credential-plugins.ts"],"names":[],"mappings":"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","sourcesContent":["import { inspect } from 'util';\nimport type { CredentialProviderSource, ForReading, ForWriting, PluginProviderResult, SDKv2CompatibleCredentials, SDKv3CompatibleCredentialProvider, SDKv3CompatibleCredentials } from '@aws-cdk/cli-plugin-contract';\nimport type { AwsCredentialIdentity, AwsCredentialIdentityProvider } from '@smithy/types';\nimport { credentialsAboutToExpire, makeCachingProvider } from './provider-caching';\nimport { debug, warning } from '../../logging';\nimport { AuthenticationError } from '../../toolkit/error';\nimport { formatErrorMessage } from '../../util/error';\nimport { Mode } from '../plugin/mode';\nimport { PluginHost } from '../plugin/plugin';\n\n/**\n * Cache for credential providers.\n *\n * Given an account and an operating mode (read or write) will return an\n * appropriate credential provider for credentials for the given account. The\n * credential provider will be cached so that multiple AWS clients for the same\n * environment will not make multiple network calls to obtain credentials.\n *\n * Will use default credentials if they are for the right account; otherwise,\n * all loaded credential provider plugins will be tried to obtain credentials\n * for the given account.\n */\nexport class CredentialPlugins {\n  private readonly cache: { [key: string]: PluginCredentialsFetchResult | undefined } = {};\n  private readonly host: PluginHost;\n\n  constructor(host?: PluginHost) {\n    this.host = host ?? PluginHost.instance;\n  }\n\n  public async fetchCredentialsFor(awsAccountId: string, mode: Mode): Promise<PluginCredentialsFetchResult | undefined> {\n    const key = `${awsAccountId}-${mode}`;\n    if (!(key in this.cache)) {\n      this.cache[key] = await this.lookupCredentials(awsAccountId, mode);\n    }\n    return this.cache[key];\n  }\n\n  public get availablePluginNames(): string[] {\n    return this.host.credentialProviderSources.map((s) => s.name);\n  }\n\n  private async lookupCredentials(awsAccountId: string, mode: Mode): Promise<PluginCredentialsFetchResult | undefined> {\n    const triedSources: CredentialProviderSource[] = [];\n    // Otherwise, inspect the various credential sources we have\n    for (const source of this.host.credentialProviderSources) {\n      let available: boolean;\n      try {\n        available = await source.isAvailable();\n      } catch (e: any) {\n        // This shouldn't happen, but let's guard against it anyway\n        warning(`Uncaught exception in ${source.name}: ${formatErrorMessage(e)}`);\n        available = false;\n      }\n\n      if (!available) {\n        debug('Credentials source %s is not available, ignoring it.', source.name);\n        continue;\n      }\n      triedSources.push(source);\n      let canProvide: boolean;\n      try {\n        canProvide = await source.canProvideCredentials(awsAccountId);\n      } catch (e: any) {\n        // This shouldn't happen, but let's guard against it anyway\n        warning(`Uncaught exception in ${source.name}: ${formatErrorMessage(e)}`);\n        canProvide = false;\n      }\n      if (!canProvide) {\n        continue;\n      }\n      debug(`Using ${source.name} credentials for account ${awsAccountId}`);\n\n      return {\n        credentials: await v3ProviderFromPlugin(() => source.getProvider(awsAccountId, mode as ForReading | ForWriting, {\n          supportsV3Providers: true,\n        })),\n        pluginName: source.name,\n      };\n    }\n    return undefined;\n  }\n}\n\n/**\n * Result from trying to fetch credentials from the Plugin host\n */\nexport interface PluginCredentialsFetchResult {\n  /**\n   * SDK-v3 compatible credential provider\n   */\n  readonly credentials: AwsCredentialIdentityProvider;\n\n  /**\n   * Name of plugin that successfully provided credentials\n   */\n  readonly pluginName: string;\n}\n\n/**\n * Take a function that calls the plugin, and turn it into an SDKv3-compatible credential provider.\n *\n * What we will do is the following:\n *\n * - Query the plugin and see what kind of result it gives us.\n * - If the result is self-refreshing or doesn't need refreshing, we turn it into an SDKv3 provider\n *   and return it directly.\n *   * If the underlying return value is a provider, we will make it a caching provider\n *     (because we can't know if it will cache by itself or not).\n *   * If the underlying return value is a static credential, caching isn't relevant.\n *   * If the underlying return value is V2 credentials, those have caching built-in.\n * - If the result is a static credential that expires, we will wrap it in an SDKv3 provider\n *   that will query the plugin again when the credential expires.\n */\nasync function v3ProviderFromPlugin(producer: () => Promise<PluginProviderResult>): Promise<AwsCredentialIdentityProvider> {\n  const initial = await producer();\n\n  if (isV3Provider(initial)) {\n    // Already a provider, make caching\n    return makeCachingProvider(initial);\n  } else if (isV3Credentials(initial) && initial.expiration === undefined) {\n    // Static credentials that don't need refreshing nor caching\n    return () => Promise.resolve(initial);\n  } else if (isV3Credentials(initial) && initial.expiration !== undefined) {\n    // Static credentials that do need refreshing and caching\n    return refreshFromPluginProvider(initial, producer);\n  } else if (isV2Credentials(initial)) {\n    // V2 credentials that refresh and cache themselves\n    return v3ProviderFromV2Credentials(initial);\n  } else {\n    throw new AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${inspect(initial)}`);\n  }\n}\n\n/**\n * Converts a V2 credential into a V3-compatible provider\n */\nfunction v3ProviderFromV2Credentials(x: SDKv2CompatibleCredentials): AwsCredentialIdentityProvider {\n  return async () => {\n    // Get will fetch or refresh as necessary\n    await x.getPromise();\n\n    return {\n      accessKeyId: x.accessKeyId,\n      secretAccessKey: x.secretAccessKey,\n      sessionToken: x.sessionToken,\n      expiration: x.expireTime ?? undefined,\n    };\n  };\n}\n\nfunction refreshFromPluginProvider(current: AwsCredentialIdentity, producer: () => Promise<PluginProviderResult>): AwsCredentialIdentityProvider {\n  return async () => {\n    if (credentialsAboutToExpire(current)) {\n      const newCreds = await producer();\n      if (!isV3Credentials(newCreds)) {\n        throw new AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${inspect(newCreds)}`);\n      }\n      current = newCreds;\n    }\n    return current;\n  };\n}\n\nfunction isV3Provider(x: PluginProviderResult): x is SDKv3CompatibleCredentialProvider {\n  return typeof x === 'function';\n}\n\nfunction isV2Credentials(x: PluginProviderResult): x is SDKv2CompatibleCredentials {\n  return !!(x && typeof x === 'object' && (x as SDKv2CompatibleCredentials).getPromise);\n}\n\nfunction isV3Credentials(x: PluginProviderResult): x is SDKv3CompatibleCredentials {\n  return !!(x && typeof x === 'object' && x.accessKeyId && !isV2Credentials(x));\n}\n"]}

package/lib/api/aws-auth/index.d.ts

@@ -0,0 +1,3 @@
+export * from './sdk';
+export * from './sdk-provider';
+export * from './sdk-logger';

package/lib/api/aws-auth/index.js

@@ -0,0 +1,20 @@
+"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("./sdk"), exports);
+__exportStar(require("./sdk-provider"), exports);
+__exportStar(require("./sdk-logger"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsd0NBQXNCO0FBQ3RCLGlEQUErQjtBQUMvQiwrQ0FBNkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3Nkayc7XG5leHBvcnQgKiBmcm9tICcuL3Nkay1wcm92aWRlcic7XG5leHBvcnQgKiBmcm9tICcuL3Nkay1sb2dnZXInO1xuIl19

package/lib/api/aws-auth/provider-caching.d.ts

@@ -0,0 +1,13 @@
+import { AwsCredentialIdentity, AwsCredentialIdentityProvider } from '@smithy/types';
+/**
+ * Wrap a credential provider in a cache
+ *
+ * Some credential providers in the SDKv3 are cached (the default Node
+ * chain, specifically) but most others are not.
+ *
+ * Since we want to avoid duplicate calls to `AssumeRole`, or duplicate
+ * MFA prompts or what have you, we are going to liberally wrap providers
+ * in caches which will return the cached value until it expires.
+ */
+export declare function makeCachingProvider(provider: AwsCredentialIdentityProvider): AwsCredentialIdentityProvider;
+export declare function credentialsAboutToExpire(token: AwsCredentialIdentity): boolean;

package/lib/api/aws-auth/provider-caching.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCachingProvider = makeCachingProvider;
+exports.credentialsAboutToExpire = credentialsAboutToExpire;
+const property_provider_1 = require("@smithy/property-provider");
+/**
+ * Wrap a credential provider in a cache
+ *
+ * Some credential providers in the SDKv3 are cached (the default Node
+ * chain, specifically) but most others are not.
+ *
+ * Since we want to avoid duplicate calls to `AssumeRole`, or duplicate
+ * MFA prompts or what have you, we are going to liberally wrap providers
+ * in caches which will return the cached value until it expires.
+ */
+function makeCachingProvider(provider) {
+    return (0, property_provider_1.memoize)(provider, credentialsAboutToExpire, (token) => !!token.expiration);
+}
+function credentialsAboutToExpire(token) {
+    const expiryMarginSecs = 5;
+    // token.expiration is sometimes null
+    return !!token.expiration && token.expiration.getTime() - Date.now() < expiryMarginSecs * 1000;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/aws-auth/sdk-logger.d.ts

@@ -0,0 +1,69 @@
+import { Logger } from '@smithy/types';
+import type { IIoHost } from '../../toolkit/cli-io-host';
+export declare class SdkToCliLogger implements Logger {
+    private readonly ioHost;
+    constructor(ioHost: IIoHost);
+    private notify;
+    trace(..._content: any[]): void;
+    debug(..._content: any[]): void;
+    /**
+     * Info is called mostly (exclusively?) for successful API calls
+     *
+     * Payload:
+     *
+     * (Note the input contains entire CFN templates, for example)
+     *
+     * ```
+     * {
+     *   clientName: 'S3Client',
+     *   commandName: 'GetBucketLocationCommand',
+     *   input: {
+     *     Bucket: '.....',
+     *     ExpectedBucketOwner: undefined
+     *   },
+     *   output: { LocationConstraint: 'eu-central-1' },
+     *   metadata: {
+     *     httpStatusCode: 200,
+     *     requestId: '....',
+     *     extendedRequestId: '...',
+     *     cfId: undefined,
+     *     attempts: 1,
+     *     totalRetryDelay: 0
+     *   }
+     * }
+     * ```
+     */
+    info(...content: any[]): void;
+    warn(...content: any[]): void;
+    /**
+     * Error is called mostly (exclusively?) for failing API calls
+     *
+     * Payload (input would be the entire API call arguments).
+     *
+     * ```
+     * {
+     *   clientName: 'STSClient',
+     *   commandName: 'GetCallerIdentityCommand',
+     *   input: {},
+     *   error: AggregateError [ECONNREFUSED]:
+     *       at internalConnectMultiple (node:net:1121:18)
+     *       at afterConnectMultiple (node:net:1688:7) {
+     *     code: 'ECONNREFUSED',
+     *     '$metadata': { attempts: 3, totalRetryDelay: 600 },
+     *     [errors]: [ [Error], [Error] ]
+     *   },
+     *   metadata: { attempts: 3, totalRetryDelay: 600 }
+     * }
+     * ```
+     */
+    error(...content: any[]): void;
+}
+/**
+ * This can be anything.
+ *
+ * For debug, it seems to be mostly strings.
+ * For info, it seems to be objects.
+ *
+ * Stringify and join without separator.
+ */
+export declare function formatSdkLoggerContent(content: any[]): string;

package/lib/api/aws-auth/sdk-logger.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkToCliLogger = void 0;
+exports.formatSdkLoggerContent = formatSdkLoggerContent;
+const util_1 = require("util");
+const serialize_1 = require("../../serialize");
+class SdkToCliLogger {
+    constructor(ioHost) {
+        this.ioHost = ioHost;
+    }
+    notify(level, ...content) {
+        void this.ioHost.notify({
+            time: new Date(),
+            level: 'trace', // always log all SDK logs at trace level, no matter what level they are coming from the SDK
+            action: 'none',
+            code: 'CDK_SDK_I0000',
+            message: (0, util_1.format)('[SDK %s] %s', level, formatSdkLoggerContent(content)),
+        });
+    }
+    trace(..._content) {
+        // This is too much detail for our logs
+        // this.notify('trace', ...content);
+    }
+    debug(..._content) {
+        // This is too much detail for our logs
+        // this.notify('debug', ...content);
+    }
+    /**
+     * Info is called mostly (exclusively?) for successful API calls
+     *
+     * Payload:
+     *
+     * (Note the input contains entire CFN templates, for example)
+     *
+     * ```
+     * {
+     *   clientName: 'S3Client',
+     *   commandName: 'GetBucketLocationCommand',
+     *   input: {
+     *     Bucket: '.....',
+     *     ExpectedBucketOwner: undefined
+     *   },
+     *   output: { LocationConstraint: 'eu-central-1' },
+     *   metadata: {
+     *     httpStatusCode: 200,
+     *     requestId: '....',
+     *     extendedRequestId: '...',
+     *     cfId: undefined,
+     *     attempts: 1,
+     *     totalRetryDelay: 0
+     *   }
+     * }
+     * ```
+     */
+    info(...content) {
+        this.notify('info', ...content);
+    }
+    warn(...content) {
+        this.notify('warn', ...content);
+    }
+    /**
+     * Error is called mostly (exclusively?) for failing API calls
+     *
+     * Payload (input would be the entire API call arguments).
+     *
+     * ```
+     * {
+     *   clientName: 'STSClient',
+     *   commandName: 'GetCallerIdentityCommand',
+     *   input: {},
+     *   error: AggregateError [ECONNREFUSED]:
+     *       at internalConnectMultiple (node:net:1121:18)
+     *       at afterConnectMultiple (node:net:1688:7) {
+     *     code: 'ECONNREFUSED',
+     *     '$metadata': { attempts: 3, totalRetryDelay: 600 },
+     *     [errors]: [ [Error], [Error] ]
+     *   },
+     *   metadata: { attempts: 3, totalRetryDelay: 600 }
+     * }
+     * ```
+     */
+    error(...content) {
+        this.notify('error', ...content);
+    }
+}
+exports.SdkToCliLogger = SdkToCliLogger;
+/**
+ * This can be anything.
+ *
+ * For debug, it seems to be mostly strings.
+ * For info, it seems to be objects.
+ *
+ * Stringify and join without separator.
+ */
+function formatSdkLoggerContent(content) {
+    if (content.length === 1) {
+        const apiFmt = formatApiCall(content[0]);
+        if (apiFmt) {
+            return apiFmt;
+        }
+    }
+    return content.map((x) => typeof x === 'string' ? x : (0, util_1.inspect)(x)).join('');
+}
+function formatApiCall(content) {
+    var _a, _b, _c, _d;
+    if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {
+        return undefined;
+    }
+    const service = content.clientName.replace(/Client$/, '');
+    const api = content.commandName.replace(/Command$/, '');
+    const parts = [];
+    if (((_b = (_a = content.metadata) === null || _a === void 0 ? void 0 : _a.attempts) !== null && _b !== void 0 ? _b : 0) > 1) {
+        parts.push(`[${(_c = content.metadata) === null || _c === void 0 ? void 0 : _c.attempts} attempts, ${(_d = content.metadata) === null || _d === void 0 ? void 0 : _d.totalRetryDelay}ms retry]`);
+    }
+    parts.push(`${service}.${api}(${JSON.stringify(content.input, serialize_1.replacerBufferWithInfo)})`);
+    if (isSdkApiCallSuccess(content)) {
+        parts.push('-> OK');
+    }
+    else {
+        parts.push(`-> ${content.error}`);
+    }
+    return parts.join(' ');
+}
+function isSdkApiCallSuccess(x) {
+    return x && typeof x === 'object' && x.commandName && x.output;
+}
+function isSdkApiCallError(x) {
+    return x && typeof x === 'object' && x.commandName && x.error;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-logger.js","sourceRoot":"","sources":["sdk-logger.ts"],"names":[],"mappings":"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","sourcesContent":["import { inspect, format } from 'util';\nimport { Logger } from '@smithy/types';\nimport { replacerBufferWithInfo } from '../../serialize';\nimport type { IIoHost } from '../../toolkit/cli-io-host';\n\nexport class SdkToCliLogger implements Logger {\n  private readonly ioHost: IIoHost;\n\n  public constructor(ioHost: IIoHost) {\n    this.ioHost = ioHost;\n  }\n\n  private notify(level: 'debug' | 'info' | 'warn' | 'error', ...content: any[]) {\n    void this.ioHost.notify({\n      time: new Date(),\n      level: 'trace', // always log all SDK logs at trace level, no matter what level they are coming from the SDK\n      action: 'none' as any,\n      code: 'CDK_SDK_I0000',\n      message: format('[SDK %s] %s', level, formatSdkLoggerContent(content)),\n    });\n  }\n\n  public trace(..._content: any[]) {\n    // This is too much detail for our logs\n    // this.notify('trace', ...content);\n  }\n\n  public debug(..._content: any[]) {\n    // This is too much detail for our logs\n    // this.notify('debug', ...content);\n  }\n\n  /**\n   * Info is called mostly (exclusively?) for successful API calls\n   *\n   * Payload:\n   *\n   * (Note the input contains entire CFN templates, for example)\n   *\n   * ```\n   * {\n   *   clientName: 'S3Client',\n   *   commandName: 'GetBucketLocationCommand',\n   *   input: {\n   *     Bucket: '.....',\n   *     ExpectedBucketOwner: undefined\n   *   },\n   *   output: { LocationConstraint: 'eu-central-1' },\n   *   metadata: {\n   *     httpStatusCode: 200,\n   *     requestId: '....',\n   *     extendedRequestId: '...',\n   *     cfId: undefined,\n   *     attempts: 1,\n   *     totalRetryDelay: 0\n   *   }\n   * }\n   * ```\n   */\n  public info(...content: any[]) {\n    this.notify('info', ...content);\n  }\n\n  public warn(...content: any[]) {\n    this.notify('warn', ...content);\n  }\n\n  /**\n   * Error is called mostly (exclusively?) for failing API calls\n   *\n   * Payload (input would be the entire API call arguments).\n   *\n   * ```\n   * {\n   *   clientName: 'STSClient',\n   *   commandName: 'GetCallerIdentityCommand',\n   *   input: {},\n   *   error: AggregateError [ECONNREFUSED]:\n   *       at internalConnectMultiple (node:net:1121:18)\n   *       at afterConnectMultiple (node:net:1688:7) {\n   *     code: 'ECONNREFUSED',\n   *     '$metadata': { attempts: 3, totalRetryDelay: 600 },\n   *     [errors]: [ [Error], [Error] ]\n   *   },\n   *   metadata: { attempts: 3, totalRetryDelay: 600 }\n   * }\n   * ```\n   */\n  public error(...content: any[]) {\n    this.notify('error', ...content);\n  }\n}\n\n/**\n * This can be anything.\n *\n * For debug, it seems to be mostly strings.\n * For info, it seems to be objects.\n *\n * Stringify and join without separator.\n */\nexport function formatSdkLoggerContent(content: any[]) {\n  if (content.length === 1) {\n    const apiFmt = formatApiCall(content[0]);\n    if (apiFmt) {\n      return apiFmt;\n    }\n  }\n  return content.map((x) => typeof x === 'string' ? x : inspect(x)).join('');\n}\n\nfunction formatApiCall(content: any): string | undefined {\n  if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {\n    return undefined;\n  }\n\n  const service = content.clientName.replace(/Client$/, '');\n  const api = content.commandName.replace(/Command$/, '');\n\n  const parts = [];\n  if ((content.metadata?.attempts ?? 0) > 1) {\n    parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);\n  }\n\n  parts.push(`${service}.${api}(${JSON.stringify(content.input, replacerBufferWithInfo)})`);\n\n  if (isSdkApiCallSuccess(content)) {\n    parts.push('-> OK');\n  } else {\n    parts.push(`-> ${content.error}`);\n  }\n\n  return parts.join(' ');\n}\n\ninterface SdkApiCallBase {\n  clientName: string;\n  commandName: string;\n  input: Record<string, unknown>;\n  metadata?: {\n    httpStatusCode?: number;\n    requestId?: string;\n    extendedRequestId?: string;\n    cfId?: string;\n    attempts?: number;\n    totalRetryDelay?: number;\n  };\n}\n\ntype SdkApiCallSuccess = SdkApiCallBase & { output: Record<string, unknown> };\ntype SdkApiCallError = SdkApiCallBase & { error: Error };\n\nfunction isSdkApiCallSuccess(x: any): x is SdkApiCallSuccess {\n  return x && typeof x === 'object' && x.commandName && x.output;\n}\n\nfunction isSdkApiCallError(x: any): x is SdkApiCallError {\n  return x && typeof x === 'object' && x.commandName && x.error;\n}\n"]}