@adobe/aio-cli-plugin-api-mesh 3.7.0 → 3.8.0-alpha.1

package/src/commands/api-mesh/__tests__/log-list.test.js

@@ -0,0 +1,162 @@
+const fs = require('fs');
+const ListLogsCommand = require('../log-list');
+const { initSdk, promptConfirm } = require('../../../helpers');
+const { getMeshId, listLogs } = require('../../../lib/devConsole');
+
+jest.mock('fs');
+jest.mock('axios');
+jest.mock('../../../helpers', () => ({
+	initSdk: jest.fn().mockResolvedValue({}),
+	initRequestId: jest.fn().mockResolvedValue({}),
+	promptConfirm: jest.fn().mockResolvedValue(true),
+}));
+jest.mock('../../../lib/devConsole');
+jest.mock('../../../classes/logger');
+
+describe('List Logs Command', () => {
+	let parseSpy;
+	let logSpy;
+
+	beforeEach(() => {
+		// Setup spies and mock functions
+		parseSpy = jest.spyOn(ListLogsCommand.prototype, 'parse').mockResolvedValue({
+			flags: {
+				filename: 'test.csv',
+				ignoreCache: false,
+			},
+		});
+
+		logSpy = jest.spyOn(ListLogsCommand.prototype, 'log');
+
+		// initRequestId.mockResolvedValue();
+		initSdk.mockResolvedValue({
+			imsOrgId: 'orgId',
+			imsOrgCode: 'orgCode',
+			projectId: 'projectId',
+			workspaceId: 'workspaceId',
+			workspaceName: 'workspaceName',
+		});
+		getMeshId.mockResolvedValue('meshId');
+		listLogs.mockResolvedValue([
+			{
+				rayId: '8c171e8a9a47c16d',
+				timestamp: 1726052061861,
+				responseStatus: 200,
+				level: 'info',
+			},
+			{
+				rayId: '8c171dd35860c16d',
+				timestamp: 1726052032540,
+				responseStatus: 200,
+				level: 'info',
+			},
+			{
+				rayId: '8c171dd22f00c16d',
+				timestamp: 1726052032348,
+				responseStatus: 200,
+				level: 'info',
+			},
+			{
+				rayId: '8c171dd10df2c16d',
+				timestamp: 1726052032167,
+				responseStatus: 200,
+				level: 'info',
+			},
+		]);
+
+		fs.existsSync.mockReturnValue(false);
+		fs.appendFileSync.mockReturnValue();
+		promptConfirm.mockResolvedValue(true);
+		global.requestId = 'dummy_request_id';
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	test('Throws an error if filename is not of csv extension', async () => {
+		// Mock the file system checks even if they are not the focus of this test
+		parseSpy.mockResolvedValue({
+			flags: {
+				filename: 'test.txt',
+				ignoreCache: false,
+			},
+		});
+
+		const command = new ListLogsCommand([], {});
+		await expect(command.run()).rejects.toThrow(
+			'Invalid file type. Provide a filename with a .csv extension.',
+		);
+	});
+
+	test('Throws an error if file already exists', async () => {
+		fs.existsSync.mockReturnValue(true);
+
+		const command = new ListLogsCommand([], {});
+		await expect(command.run()).rejects.toThrow(
+			'File test.csv already exists. Provide a new file name.',
+		);
+	});
+
+	test('Throws an error is meshId is not found', async () => {
+		getMeshId.mockResolvedValue(null);
+
+		const command = new ListLogsCommand([], {});
+		const result = command.run();
+		result.catch(err => {
+			expect(err.message).toMatchInlineSnapshot(
+				`"Unable to get mesh config. No mesh found for Org(orgId) -> Project(projectId) -> Workspace(workspaceId). Check the details and try again. RequestId: dummy_request_id"`,
+			);
+		});
+	});
+
+	test('Logs are listed successfully with file as output', async () => {
+		const command = new ListLogsCommand([], {});
+		await command.run();
+		expect(fs.appendFileSync).toHaveBeenCalled();
+	});
+
+	test('Logs are listed successfully', async () => {
+		parseSpy.mockResolvedValue({
+			flags: {
+				ignoreCache: false,
+			},
+		});
+		const command = new ListLogsCommand([], {});
+		await command.run();
+		expect(fs.appendFileSync).not.toHaveBeenCalled();
+	});
+
+	test('No logs found message displayed when sms returns empty array with file as output', async () => {
+		listLogs.mockResolvedValue([]);
+		const command = new ListLogsCommand([], {});
+		await command.run();
+		expect(fs.appendFileSync).not.toHaveBeenCalled();
+		expect(logSpy).toHaveBeenCalledWith(
+			`No recent logs found. Alternatively, you can use the following command to get all logs for a 30 minute time period: \naio api-mesh log-get-bulk --startTime YYYY-MM-DDTHH:MM:SSZ --endTime YYYY-MM-DDTHH:MM:SSZ --filename mesh_logs.csv`,
+		);
+	});
+
+	test('No logs found message displayed when sms returns empty array', async () => {
+		parseSpy.mockResolvedValue({
+			flags: {
+				ignoreCache: false,
+			},
+		});
+		listLogs.mockResolvedValue([]);
+		const command = new ListLogsCommand([], {});
+		await command.run();
+		expect(logSpy).toHaveBeenCalledWith(
+			`No recent logs found. Alternatively, you can use the following command to get all logs for a 30 minute time period: \naio api-mesh log-get-bulk --startTime YYYY-MM-DDTHH:MM:SSZ --endTime YYYY-MM-DDTHH:MM:SSZ --filename mesh_logs.csv`,
+		);
+		expect(fs.appendFileSync).not.toHaveBeenCalled();
+	});
+
+	test('Throw an error if SMS call fails', async () => {
+		listLogs.mockRejectedValue(new Error('SMS call failed'));
+		const command = new ListLogsCommand([], {});
+		await expect(command.run()).rejects.toThrow(
+			'Failed to list recent logs, RequestId: dummy_request_id',
+		);
+	});
+});

package/src/commands/api-mesh/log-get-bulk.js

@@ -0,0 +1,243 @@
+const { Command } = require('@oclif/core');
+const path = require('path');
+const fs = require('fs');
+const { initRequestId, initSdk, promptConfirm } = require('../../helpers');
+const { getMeshId, getPresignedUrls } = require('../../lib/devConsole');
+const logger = require('../../classes/logger');
+const axios = require('axios');
+const {
+	ignoreCacheFlag,
+	startTimeFlag,
+	endTimeFlag,
+	logFilenameFlag,
+	suggestCorrectedDateFormat,
+} = require('../../utils');
+
+require('dotenv').config();
+
+class GetBulkLogCommand extends Command {
+	static flags = {
+		ignoreCache: ignoreCacheFlag,
+		startTime: startTimeFlag,
+		endTime: endTimeFlag,
+		filename: logFilenameFlag,
+	};
+
+	async run() {
+		// Column headers to be written as the first row in the output file
+		const columnHeaders =
+			'EventTimestampMs,Exceptions,Logs,Outcome,MeshId,RayID,URL,Request Method,Response Status,Level';
+
+		await initRequestId();
+		logger.info(`RequestId: ${global.requestId}`);
+		const { flags } = await this.parse(GetBulkLogCommand);
+		const ignoreCache = await flags.ignoreCache;
+
+		const filename = await flags.filename;
+
+		// Only supports files that end with .csv
+		if (!filename || path.extname(filename).toLowerCase() !== '.csv') {
+			this.error('Invalid file type. Provide a filename with a .csv extension.');
+			return;
+		}
+		// Regular expression to validate the input date format YYYY-MM-DDTHH:MM:SSZ
+		const dateTimeRegex = /^(?:(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T(0[0-9]|1[0-9]|2[0-3]):([0-5]\d):([0-5]\d)Z)$/;
+
+		// Validate user provided startTime format
+		if (!dateTimeRegex.test(flags.startTime)) {
+			const correctedStartTime = suggestCorrectedDateFormat(flags.startTime);
+			if (!correctedStartTime) {
+				this.error('Found invalid date components for startTime. Check and correct the date.');
+			} else {
+				this.error(
+					`Use the format YYYY-MM-DDTHH:MM:SSZ for startTime. Did you mean ${correctedStartTime}?`,
+				);
+			}
+
+			return;
+		}
+
+		// Validate user provided endTime format
+		if (!dateTimeRegex.test(flags.endTime)) {
+			const correctedEndTime = suggestCorrectedDateFormat(flags.endTime);
+			//check for incorrect date components
+			if (!correctedEndTime) {
+				this.error('Found invalid date components for endTime. Check and correct the date.');
+			} else {
+				this.error(
+					`Use the format YYYY-MM-DDTHH:MM:SSZ for endTime. Did you mean ${correctedEndTime}?`,
+				);
+			}
+			return;
+		}
+
+		// Properly format startTime and endTime strings before handing it over to SMS
+		const formattedStartTime = flags.startTime.replace(/-|:|Z/g, '').replace('T', 'T');
+		const formattedEndTime = flags.endTime.replace(/-|:|Z/g, '').replace('T', 'T');
+
+		// Convert formatted times to Date objects for comparison
+		const startTime = new Date(flags.startTime);
+		const endTime = new Date(flags.endTime);
+
+		// Require both startTime and endTime
+		if (!startTime || !endTime) {
+			this.error('Provide both startTime and endTime.');
+			return;
+		}
+
+		// Get the current date and calculate the date 30 days ago, both in UTC
+		const today = new Date();
+		const thirtyDaysAgo = new Date(today);
+		thirtyDaysAgo.setUTCDate(today.getUTCDate() - 30);
+		// Validate that logs from beyond 30 days from today are not available
+		if (startTime < thirtyDaysAgo || endTime < thirtyDaysAgo) {
+			this.error('Cannot get logs more than 30 days old. Adjust your time range.');
+			return;
+		}
+
+		// Validate required filename flag
+		if (!filename) {
+			this.error('Missing filename. Provide a valid file in the current working directory.');
+			return;
+		}
+
+		// Check if the file exists
+		const outputFile = path.resolve(process.cwd(), filename);
+
+		// Check if file exists and if doesn't, create one in the cwd and continue
+		if (!fs.existsSync(outputFile)) {
+			fs.writeFileSync(outputFile, '');
+		}
+
+		//check if the file is empty before proceeding
+		const stats = fs.statSync(outputFile);
+		if (stats.size > 0) {
+			throw new Error(`Make sure the file: ${filename} is empty`);
+		}
+		// truncate milliseconds to ensure comparison is only done up to seconds
+		startTime.setMilliseconds(0);
+		endTime.setMilliseconds(0);
+
+		// Validate startTime < endTime
+		if (startTime > endTime) {
+			this.error('endTime must be greater than startTime');
+		}
+
+		// 4. Check if the duration between start and end times is greater than 30 minutes (1800 seconds)
+		const timeDifferenceInSeconds = (endTime.getTime() - startTime.getTime()) / 1000;
+
+		if (timeDifferenceInSeconds > 1800) {
+			const hours = Math.floor(timeDifferenceInSeconds / 3600); //hours calculation
+			const minutes = Math.floor((timeDifferenceInSeconds % 3600) / 60); //minutes calculation
+			const seconds = timeDifferenceInSeconds % 60; //seconds calculation
+
+			this.error(
+				`Max duration between startTime and endTime should be 30 minutes. Current duration is ${hours} hour${
+					hours !== 1 ? 's' : ''
+				} ${minutes} minute${minutes !== 1 ? 's' : ''} and ${seconds} second${
+					seconds !== 1 ? 's' : ''
+				}.`,
+			);
+			return;
+		}
+		logger.info('Calling initSdk...');
+		const { imsOrgId, imsOrgCode, projectId, workspaceId, workspaceName } = await initSdk({
+			ignoreCache,
+		});
+
+		// Retrieve meshId
+		let meshId = null;
+		try {
+			meshId = await getMeshId(imsOrgId, projectId, workspaceId, workspaceName);
+		} catch (err) {
+			this.error(`Unable to get mesh ID: ${err.message}.`);
+		}
+
+		if (!meshId) {
+			this.error('Mesh ID not found.');
+		}
+
+		// 5. Call downloadFiles
+		const { presignedUrls, totalSize } = await getPresignedUrls(
+			imsOrgCode,
+			projectId,
+			workspaceId,
+			meshId,
+			formattedStartTime,
+			formattedEndTime,
+		);
+		//If presigned URLs are not found, throw error saying that no logs are found
+		if (!presignedUrls || presignedUrls.length === 0) {
+			this.error('No logs found for the given time range.');
+		}
+
+		let shouldDownload = false;
+		if (totalSize > 0) {
+			const totalSizeKB = (totalSize / 1024).toFixed(2); // Convert bytes to KB
+			// 7. Get user confirmation
+			shouldDownload = await promptConfirm(
+				`The expected file size is ${totalSizeKB} KB. Confirm ${filename} download? (y/n)`,
+			);
+			if (shouldDownload) {
+				//create a writer and proceed with download
+				const writer = fs.createWriteStream(outputFile, { flags: 'a' });
+
+				// Write the column headers before appending the log content
+				writer.write(`${columnHeaders}\n`);
+
+				// Stream the data from the signed URLs
+				for (const urlObj of presignedUrls) {
+					const { key, url } = urlObj;
+					logger.info(`Downloading ${key} and appending to ${outputFile}...`);
+
+					try {
+						const fileContentStream = await this.downloadFileContent(url);
+						fileContentStream.pipe(writer, { end: false });
+
+						await new Promise((resolve, reject) => {
+							fileContentStream.on('end', resolve);
+							fileContentStream.on('error', reject);
+						});
+						// write a newline after each file write
+						writer.write('\n');
+
+						logger.info(`${key} content appended successfully.`);
+					} catch (error) {
+						logger.error(`Error downloading or appending content of ${key}:`, error);
+					}
+				}
+				// Ensure the stream is closed
+				writer.end();
+
+				this.log(`Successfully downloaded the logs to ${filename}.`);
+			} else {
+				this.log('Log files not downloaded.');
+			}
+		} else {
+			this.error('No logs available to download');
+		}
+	}
+	/**
+	 * Downloads the content of a file from the provided presigned URL.
+	 *
+	 * @param {string} url  - presigned URL to download the log from
+	 * @returns {Promise<Stream.Readable>} - A promise that resolves to a readable stream of the file content
+	 */
+
+	async downloadFileContent(url) {
+		return axios({
+			method: 'get',
+			url: url,
+			responseType: 'stream',
+		})
+			.then(response => response.data)
+			.catch(error => {
+				logger.error('Error downloading log content:', error.message);
+				throw error;
+			});
+	}
+}
+
+GetBulkLogCommand.description = 'Download all mesh logs for a selected time period.';
+
+module.exports = GetBulkLogCommand;

package/src/commands/api-mesh/log-get.js

@@ -0,0 +1,83 @@
+/*
+Copyright 2021 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+const { Command } = require('@oclif/core');
+const logger = require('../../classes/logger');
+const { initSdk, initRequestId } = require('../../helpers');
+const { ignoreCacheFlag } = require('../../utils');
+const { getMeshId, getLogsByRayId } = require('../../lib/devConsole');
+require('dotenv').config();
+
+class FetchLogsCommand extends Command {
+	static args = [{ name: 'rayId', required: true, description: 'Fetch a single log by rayID' }];
+	static flags = {
+		ignoreCache: ignoreCacheFlag,
+	};
+
+	async run() {
+		await initRequestId();
+
+		logger.info(`RequestId: ${global.requestId}`);
+
+		const { args, flags } = await this.parse(FetchLogsCommand);
+
+		const ignoreCache = flags.ignoreCache;
+		const rayId = args.rayId;
+
+		const { imsOrgId, imsOrgCode, projectId, workspaceId } = await initSdk({
+			ignoreCache,
+		});
+
+		let meshId = null;
+		try {
+			meshId = await getMeshId(imsOrgId, projectId, workspaceId, meshId);
+			if (!meshId) {
+				throw new Error('MeshIdNotFound');
+			}
+		} catch (err) {
+			this.error(
+				`Unable to get mesh ID. Please check the details and try again. RequestId: ${global.requestId}`,
+			);
+		}
+
+		try {
+			const meshLog = await getLogsByRayId(imsOrgCode, projectId, workspaceId, meshId, rayId);
+			if (meshLog) {
+				this.log('Event Timestamp : %s', meshLog.eventTimestampMs);
+				this.log('Exceptions : %s', meshLog.exceptions);
+				this.log('Logs : %s', meshLog.logs);
+				this.log('Outcome : %s', meshLog.outcome);
+				this.log('Mesh ID : %s', meshLog.meshId);
+				this.log('RayId : %s', meshLog.rayId);
+				this.log('Mesh URL : %s', meshLog.url);
+				this.log('Request Method : %s', meshLog.requestMethod);
+				this.log('Request Status : %s', meshLog.responseStatus);
+			}
+		} catch (error) {
+			if (error.message === 'LogNotFound') {
+				this.error(
+					`No logs found for RayID ${rayId}. Check the RayID and try again. RequestId: ${global.requestId}. Alternatively, you can use the following command to get all logs for a 30 minute time period: \naio api-mesh log-get-bulk --startTime YYYY-MM-DDTHH:MM:SSZ --endTime YYYY-MM-DDTHH:MM:SSZ --filename mesh_logs.csv`,
+				);
+			} else if (error.message === 'ServerError') {
+				this.error(
+					`Server error while fetching logs for RayId ${rayId}. Please try again later. RequestId: ${global.requestId}`,
+				);
+			} else {
+				this.error(
+					`Unable to get mesh logs. Please check the details and try again. If the error persists please contact support. RequestId: ${global.requestId}`,
+				);
+			}
+		}
+	}
+}
+
+FetchLogsCommand.description = 'Get the Log of a given mesh by RayId';
+
+module.exports = FetchLogsCommand;

package/src/commands/api-mesh/log-list.js

@@ -0,0 +1,105 @@
+const { Command } = require('@oclif/core');
+
+const logger = require('../../classes/logger');
+const { initSdk, initRequestId } = require('../../helpers');
+const { ignoreCacheFlag, fileNameFlag } = require('../../utils');
+const { getMeshId, listLogs } = require('../../lib/devConsole');
+const { appendFileSync, existsSync } = require('fs');
+const { ux } = require('@oclif/core/lib/cli-ux');
+const path = require('path');
+
+require('dotenv').config();
+class ListLogsCommand extends Command {
+	static flags = {
+		ignoreCache: ignoreCacheFlag,
+		filename: fileNameFlag,
+	};
+
+	static enableJsonFlag = true;
+
+	async run() {
+		await initRequestId();
+
+		logger.info(`RequestId: ${global.requestId}`);
+
+		const { flags } = await this.parse(ListLogsCommand);
+
+		const { ignoreCache, filename } = await flags;
+
+		if (filename) {
+			if (path.extname(filename).toLowerCase() !== '.csv') {
+				this.error('Invalid file type. Provide a filename with a .csv extension.');
+			}
+			const file = path.resolve(process.cwd(), filename);
+			if (existsSync(file)) {
+				this.error(`File ${filename} already exists. Provide a new file name.`);
+			}
+		}
+
+		const { imsOrgId, imsOrgCode, projectId, workspaceId, workspaceName } = await initSdk({
+			ignoreCache,
+		});
+
+		let meshId = null;
+
+		try {
+			meshId = await getMeshId(imsOrgId, projectId, workspaceId, workspaceName);
+		} catch (err) {
+			this.error(
+				`Unable to get mesh ID. Check the details and try again. RequestId: ${global.requestId}`,
+			);
+		}
+		if (meshId) {
+			try {
+				const logs = await listLogs(imsOrgCode, projectId, workspaceId, meshId, filename);
+
+				if (logs && logs.length > 0) {
+					// add a new line
+					this.log();
+					ux.table(
+						logs,
+						{
+							rayId: {
+								header: 'Ray ID',
+								minWidth: 15,
+							},
+							timestamp: {
+								header: 'Timestamp',
+								minWidth: 15,
+							},
+							responseStatus: {
+								header: 'Response Status',
+								minWidth: 15,
+							},
+							level: {
+								header: 'Level',
+								minWidth: 15,
+							},
+						},
+						{
+							printLine: filename
+								? line => appendFileSync(filename, line + '\n')
+								: line => this.log(line),
+							csv: filename,
+							...flags,
+						},
+					);
+				} else {
+					this.log(
+						'No recent logs found. Alternatively, you can use the following command to get all logs for a 30 minute time period: \naio api-mesh log-get-bulk --startTime YYYY-MM-DDTHH:MM:SSZ --endTime YYYY-MM-DDTHH:MM:SSZ --filename mesh_logs.csv',
+					);
+				}
+			} catch (error) {
+				this.error(`Failed to list recent logs, RequestId: ${global.requestId}`);
+			}
+		} else {
+			this.error(
+				`Unable to get mesh config. No mesh found for Org(${imsOrgId}) -> Project(${projectId}) -> Workspace(${workspaceId}). Check the details and try again. RequestId: ${global.requestId}`,
+			);
+		}
+	}
+}
+
+ListLogsCommand.description = 'Get recent logs of requests made to the API Mesh.';
+
+module.exports = ListLogsCommand;