@nest-omni/core 3.1.2-7 → 3.1.2-9

package/http-client/services/http-log-query.service.js

@@ -0,0 +1,590 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var HttpLogQueryService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLogQueryService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const http_log_entity_1 = require("../entities/http-log.entity");
+const curl_generator_util_1 = require("../utils/curl-generator.util");
+let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.logger = new common_1.Logger(HttpLogQueryService_1.name);
+        this.logRepository = null;
+        this.initializeRepository();
+    }
+    findLogs() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const { page = 1, limit = 50, sortBy = 'createdAt', sortOrder = 'DESC', includeDetails = false, } = options;
+            const queryBuilder = this.buildQuery(options, includeDetails);
+            const offset = (page - 1) * limit;
+            queryBuilder.skip(offset).take(limit);
+            queryBuilder.orderBy(`log.${sortBy}`, sortOrder);
+            const [logs, total] = yield queryBuilder.getManyAndCount();
+            return {
+                logs,
+                total,
+                page,
+                limit,
+                totalPages: Math.ceil(total / limit),
+            };
+        });
+    }
+    findLogById(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, includeDetails = false) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const queryBuilder = this.logRepository.createQueryBuilder('log');
+            if (includeDetails) {
+                queryBuilder.leftJoinAndSelect('log.retryRecords', 'retryRecords');
+            }
+            return queryBuilder.where('log.id = :id', { id }).getOne();
+        });
+    }
+    findLogByRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            return this.logRepository.findOne({
+                where: { requestId },
+                order: { createdAt: 'DESC' },
+            });
+        });
+    }
+    findErrorLogs() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const queryOptions = Object.assign(Object.assign({}, options), { success: false });
+            return this.findLogs(queryOptions);
+        });
+    }
+    findSlowRequests() {
+        return __awaiter(this, arguments, void 0, function* (minResponseTime = 5000, options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const { page = 1, limit = 50 } = options;
+            const offset = (page - 1) * limit;
+            const [logs, total] = yield this.logRepository
+                .createQueryBuilder('log')
+                .where('log.responseTime >= :minResponseTime', { minResponseTime })
+                .orderBy('log.responseTime', 'DESC')
+                .skip(offset)
+                .take(limit)
+                .getManyAndCount();
+            return { logs, total };
+        });
+    }
+    findRetryLogs() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const { minRetries = 1, page = 1, limit = 50 } = options;
+            const offset = (page - 1) * limit;
+            const queryBuilder = this.logRepository
+                .createQueryBuilder('log')
+                .where('log.attemptCount > :minRetries', { minRetries: minRetries - 1 })
+                .orderBy('log.attemptCount', 'DESC')
+                .addOrderBy('log.createdAt', 'DESC')
+                .skip(offset)
+                .take(limit);
+            const [logs, total] = yield queryBuilder.getManyAndCount();
+            return { logs, total };
+        });
+    }
+    getStats() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const { startDate, endDate, userId, serviceName } = options;
+            const baseQuery = this.logRepository.createQueryBuilder('log');
+            if (startDate) {
+                baseQuery.andWhere('log.createdAt >= :startDate', { startDate });
+            }
+            if (endDate) {
+                baseQuery.andWhere('log.createdAt <= :endDate', { endDate });
+            }
+            if (userId) {
+                baseQuery.andWhere('log.userId = :userId', { userId });
+            }
+            if (serviceName) {
+                baseQuery.andWhere('log.serviceName = :serviceName', { serviceName });
+            }
+            const [total, successful, failed] = yield Promise.all([
+                baseQuery.getCount(),
+                baseQuery
+                    .clone()
+                    .andWhere('log.success = :success', { success: true })
+                    .getCount(),
+                baseQuery
+                    .clone()
+                    .andWhere('log.success = :success', { success: false })
+                    .getCount(),
+            ]);
+            const responseTimeStats = yield baseQuery
+                .select('AVG(log.responseTime)', 'avg')
+                .addSelect('MIN(log.responseTime)', 'min')
+                .addSelect('MAX(log.responseTime)', 'max')
+                .getRawOne();
+            const httpMethodStats = yield baseQuery
+                .select('log.method', 'method')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.method')
+                .getRawMany();
+            const statusStats = yield baseQuery
+                .select('log.statusCode', 'statusCode')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.statusCode')
+                .getRawMany();
+            const serviceStats = yield baseQuery
+                .select('log.serviceName', 'serviceName')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.serviceName')
+                .getRawMany();
+            const operationStats = yield baseQuery
+                .select('log.operationName', 'operationName')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.operationName')
+                .getRawMany();
+            const sourceStats = yield baseQuery
+                .select('log.source', 'source')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.source')
+                .getRawMany();
+            const errorStats = yield baseQuery
+                .clone()
+                .where('log.success = :success', { success: false })
+                .select('log.errorCode', 'errorCode')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.errorCode')
+                .getRawMany();
+            const retryStats = yield baseQuery
+                .select('AVG(log.attemptCount)', 'avgAttempts')
+                .addSelect('MAX(log.attemptCount)', 'maxAttempts')
+                .addSelect('SUM(log.attemptCount - 1)', 'totalRetries')
+                .addSelect('COUNT(*)', 'totalRequests')
+                .getRawOne();
+            const cacheStats = yield baseQuery
+                .select('SUM(CASE WHEN log.cacheHit = true THEN 1 ELSE 0 END)', 'cacheHits')
+                .addSelect('SUM(CASE WHEN log.cacheHit = false OR log.cacheHit IS NULL THEN 1 ELSE 0 END)', 'cacheMisses')
+                .addSelect('COUNT(*)', 'total')
+                .getRawOne();
+            const percentiles = yield this.calculatePercentiles(baseQuery);
+            return {
+                totalRequests: total,
+                successfulRequests: successful,
+                failedRequests: failed,
+                successRate: total > 0 ? (successful / total) * 100 : 0,
+                averageResponseTime: (responseTimeStats === null || responseTimeStats === void 0 ? void 0 : responseTimeStats.avg) || 0,
+                minResponseTime: (responseTimeStats === null || responseTimeStats === void 0 ? void 0 : responseTimeStats.min) || 0,
+                maxResponseTime: (responseTimeStats === null || responseTimeStats === void 0 ? void 0 : responseTimeStats.max) || 0,
+                p50ResponseTime: percentiles.p50,
+                p95ResponseTime: percentiles.p95,
+                p99ResponseTime: percentiles.p99,
+                requestsByMethod: this.formatStats(httpMethodStats, 'method', 'count'),
+                requestsByStatus: this.formatStats(statusStats, 'statusCode', 'count'),
+                requestsByService: this.formatStats(serviceStats, 'serviceName', 'count'),
+                requestsBySource: this.formatStats(sourceStats, 'source', 'count'),
+                errorsByCode: this.formatStats(errorStats, 'errorCode', 'count'),
+                retryStats: {
+                    totalRetries: (retryStats === null || retryStats === void 0 ? void 0 : retryStats.totalRetries) || 0,
+                    averageRetries: (retryStats === null || retryStats === void 0 ? void 0 : retryStats.avgAttempts)
+                        ? parseFloat(retryStats.avgAttempts) - 1
+                        : 0,
+                    maxRetries: (retryStats === null || retryStats === void 0 ? void 0 : retryStats.maxAttempts)
+                        ? parseInt(retryStats.maxAttempts) - 1
+                        : 0,
+                    retryRate: total > 0 ? (((retryStats === null || retryStats === void 0 ? void 0 : retryStats.totalRetries) || 0) / total) * 100 : 0,
+                },
+                cacheStats: {
+                    cacheHits: (cacheStats === null || cacheStats === void 0 ? void 0 : cacheStats.cacheHits) || 0,
+                    cacheMisses: (cacheStats === null || cacheStats === void 0 ? void 0 : cacheStats.cacheMisses) || 0,
+                    cacheHitRate: (cacheStats === null || cacheStats === void 0 ? void 0 : cacheStats.total) > 0
+                        ? (((cacheStats === null || cacheStats === void 0 ? void 0 : cacheStats.cacheHits) || 0) / cacheStats.total) * 100
+                        : 0,
+                },
+            };
+        });
+    }
+    deleteOldLogs() {
+        return __awaiter(this, arguments, void 0, function* (daysToKeep = 30) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+            const result = yield this.logRepository
+                .createQueryBuilder()
+                .delete()
+                .where('createdAt < :cutoffDate', { cutoffDate })
+                .execute();
+            this.logger.log(`Deleted ${result.affected} old HTTP logs (older than ${daysToKeep} days)`);
+            return result.affected || 0;
+        });
+    }
+    clearAllLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            yield this.logRepository.clear();
+            this.logger.warn('Cleared all HTTP logs');
+            return 0;
+        });
+    }
+    generateCurlFromLog(logId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.logRepository.findOne({
+                where: { id: logId },
+            });
+            if (!log) {
+                this.logger.warn(`Log with ID ${logId} not found`);
+                return null;
+            }
+            try {
+                const sanitizedHeaders = this.sanitizeHeadersForCurl(log.headers || {});
+                const requestConfig = {
+                    method: log.method,
+                    url: log.url,
+                    headers: sanitizedHeaders,
+                    data: log.body,
+                    params: log.params,
+                };
+                const curlCommand = curl_generator_util_1.CurlGenerator.generateCurlCommand(requestConfig);
+                this.logger.log(`Generated curl command for log ${logId}`);
+                return curlCommand;
+            }
+            catch (error) {
+                this.logger.error(`Failed to generate curl command for log ${logId}`, error);
+                return null;
+            }
+        });
+    }
+    generateCurlFromRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.logRepository.findOne({
+                where: { requestId },
+                order: { createdAt: 'DESC' },
+            });
+            if (!log) {
+                this.logger.warn(`Log with requestId ${requestId} not found`);
+                return null;
+            }
+            return this.generateCurlFromLog(log.id);
+        });
+    }
+    generateReplayConfigFromLog(logId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.logRepository.findOne({
+                where: { id: logId },
+            });
+            if (!log) {
+                this.logger.warn(`Log with ID ${logId} not found`);
+                return null;
+            }
+            try {
+                const replayConfig = {
+                    method: log.method,
+                    url: log.url,
+                    headers: log.headers || {},
+                    data: log.body
+                        ? typeof log.body === 'string'
+                            ? JSON.parse(log.body)
+                            : log.body
+                        : undefined,
+                    params: log.params || {},
+                    metadata: {
+                        originalLogId: log.id,
+                        originalRequestId: log.requestId,
+                        replayTimestamp: new Date().toISOString(),
+                        replayedBy: 'http-log-query-service',
+                    },
+                };
+                this.logger.log(`Generated replay config for log ${logId}`);
+                return replayConfig;
+            }
+            catch (error) {
+                this.logger.error(`Failed to generate replay config for log ${logId}`, error);
+                return null;
+            }
+        });
+    }
+    generateReplayConfigFromRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.logRepository.findOne({
+                where: { requestId },
+                order: { createdAt: 'DESC' },
+            });
+            if (!log) {
+                this.logger.warn(`Log with requestId ${requestId} not found`);
+                return null;
+            }
+            return this.generateReplayConfigFromLog(log.id);
+        });
+    }
+    generateBatchCurlCommands() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const limitedOptions = Object.assign(Object.assign({}, options), { limit: Math.min(options.limit || 10, 50) });
+            const result = yield this.findLogs(limitedOptions);
+            const curlCommands = [];
+            for (const log of result.logs) {
+                try {
+                    const curlCommand = yield this.generateCurlFromLog(log.id);
+                    if (curlCommand) {
+                        curlCommands.push({
+                            logId: log.id,
+                            requestId: log.requestId,
+                            curlCommand,
+                        });
+                    }
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to generate curl for log ${log.id}`, error);
+                }
+            }
+            this.logger.log(`Generated ${curlCommands.length} curl commands`);
+            return curlCommands;
+        });
+    }
+    getLogReplayInfo(logId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const log = yield this.findLogById(logId, true);
+            if (!log) {
+                return null;
+            }
+            const [curlCommand, replayConfig] = yield Promise.all([
+                this.generateCurlFromLog(logId),
+                this.generateReplayConfigFromLog(logId),
+            ]);
+            return {
+                log,
+                curlCommand,
+                replayConfig,
+            };
+        });
+    }
+    getLogReplayInfoByRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const log = yield this.findLogByRequestId(requestId);
+            if (!log) {
+                return null;
+            }
+            return this.getLogReplayInfo(log.id);
+        });
+    }
+    initializeRepository() {
+        if (this.dataSource) {
+            try {
+                this.logRepository = this.dataSource.getRepository(http_log_entity_1.HttpLogEntity);
+                this.logger.log('HTTP log repository initialized');
+            }
+            catch (error) {
+                this.logger.error('Failed to initialize HTTP log repository', error);
+            }
+        }
+    }
+    calculatePercentiles(queryBuilder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const results = yield queryBuilder
+                    .select('log.responseTime', 'responseTime')
+                    .where('log.responseTime IS NOT NULL')
+                    .orderBy('log.responseTime', 'ASC')
+                    .getRawMany();
+                if (results.length === 0) {
+                    return { p50: 0, p95: 0, p99: 0 };
+                }
+                const responseTimes = results
+                    .map((r) => r.responseTime)
+                    .sort((a, b) => a - b);
+                const total = responseTimes.length;
+                const getPercentile = (p) => {
+                    const index = Math.ceil((p / 100) * total) - 1;
+                    return responseTimes[Math.max(0, index)];
+                };
+                return {
+                    p50: getPercentile(50),
+                    p95: getPercentile(95),
+                    p99: getPercentile(99),
+                };
+            }
+            catch (error) {
+                this.logger.warn('Failed to calculate percentiles', error);
+                return { p50: 0, p95: 0, p99: 0 };
+            }
+        });
+    }
+    formatStats(stats, keyField, valueField) {
+        return stats.reduce((acc, item) => {
+            const key = item[keyField] || 'unknown';
+            const value = parseInt(item[valueField]) || 0;
+            acc[key] = value;
+            return acc;
+        }, {});
+    }
+    buildQuery(options, includeDetails = false) {
+        if (!this.logRepository) {
+            throw new Error('HTTP log repository not available');
+        }
+        const queryBuilder = this.logRepository.createQueryBuilder('log');
+        if (includeDetails) {
+            queryBuilder.leftJoinAndSelect('log.retryRecords', 'retryRecords');
+        }
+        if (options.requestId) {
+            queryBuilder.andWhere('log.requestId = :requestId', {
+                requestId: options.requestId,
+            });
+        }
+        if (options.userId) {
+            queryBuilder.andWhere('log.userId = :userId', { userId: options.userId });
+        }
+        if (options.method) {
+            if (Array.isArray(options.method)) {
+                queryBuilder.andWhere('log.method IN (:...methods)', {
+                    methods: options.method,
+                });
+            }
+            else {
+                queryBuilder.andWhere('log.method = :method', {
+                    method: options.method,
+                });
+            }
+        }
+        if (options.url) {
+            queryBuilder.andWhere('log.url LIKE :url', { url: `%${options.url}%` });
+        }
+        if (options.statusCode) {
+            if (Array.isArray(options.statusCode)) {
+                queryBuilder.andWhere('log.statusCode IN (:...statusCodes)', {
+                    statusCodes: options.statusCode,
+                });
+            }
+            else {
+                queryBuilder.andWhere('log.statusCode = :statusCode', {
+                    statusCode: options.statusCode,
+                });
+            }
+        }
+        if (options.success !== undefined) {
+            queryBuilder.andWhere('log.success = :success', {
+                success: options.success,
+            });
+        }
+        if (options.serviceName) {
+            queryBuilder.andWhere('log.serviceName = :serviceName', {
+                serviceName: options.serviceName,
+            });
+        }
+        if (options.operationName) {
+            queryBuilder.andWhere('log.operationName = :operationName', {
+                operationName: options.operationName,
+            });
+        }
+        if (options.clientIp) {
+            queryBuilder.andWhere('log.clientIp = :clientIp', {
+                clientIp: options.clientIp,
+            });
+        }
+        if (options.source) {
+            queryBuilder.andWhere('log.source = :source', { source: options.source });
+        }
+        if (options.tags && options.tags.length > 0) {
+            queryBuilder.andWhere('JSON_CONTAINS(log.tags, :tags)', {
+                tags: JSON.stringify(options.tags),
+            });
+        }
+        if (options.errorCode) {
+            queryBuilder.andWhere('log.errorCode = :errorCode', {
+                errorCode: options.errorCode,
+            });
+        }
+        if (options.minResponseTime) {
+            queryBuilder.andWhere('log.responseTime >= :minResponseTime', {
+                minResponseTime: options.minResponseTime,
+            });
+        }
+        if (options.maxResponseTime) {
+            queryBuilder.andWhere('log.responseTime <= :maxResponseTime', {
+                maxResponseTime: options.maxResponseTime,
+            });
+        }
+        if (options.startDate) {
+            queryBuilder.andWhere('log.createdAt >= :startDate', {
+                startDate: options.startDate,
+            });
+        }
+        if (options.endDate) {
+            queryBuilder.andWhere('log.createdAt <= :endDate', {
+                endDate: options.endDate,
+            });
+        }
+        if (options.keyword) {
+            queryBuilder.andWhere('(log.url LIKE :keyword OR log.errorMessage LIKE :keyword OR log.body LIKE :keyword)', { keyword: `%${options.keyword}%` });
+        }
+        return queryBuilder;
+    }
+    sanitizeHeadersForCurl(headers) {
+        const sensitiveHeaders = [
+            'authorization',
+            'apikey',
+            'x-api-key',
+            'x-auth-token',
+            'cookie',
+            'set-cookie',
+        ];
+        const sanitized = Object.assign({}, headers);
+        for (const header of sensitiveHeaders) {
+            if (sanitized[header]) {
+                sanitized[header] = '***REDACTED***';
+            }
+        }
+        return sanitized;
+    }
+};
+exports.HttpLogQueryService = HttpLogQueryService;
+exports.HttpLogQueryService = HttpLogQueryService = HttpLogQueryService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], HttpLogQueryService);

package/http-client/services/http-replay.service.d.ts

@@ -0,0 +1,58 @@
+import { AxiosRequestConfig } from 'axios';
+import { HttpClientService } from './http-client.service';
+import { HttpLogQueryService } from './http-log-query.service';
+import { HttpLogEntity } from '../entities/http-log.entity';
+export interface HttpReplayOptions {
+    overrideHeaders?: boolean;
+    overrideBody?: boolean;
+    overrideParams?: boolean;
+    additionalHeaders?: Record<string, string>;
+    metadata?: Record<string, any>;
+    logReplay?: boolean;
+    timeout?: number;
+}
+export interface HttpReplayResult {
+    originalLog: HttpLogEntity;
+    requestConfig: AxiosRequestConfig;
+    response: any;
+    responseTime: number;
+    success: boolean;
+    error?: string;
+    replayTimestamp: string;
+    replayId: string;
+}
+export interface BatchReplayResult {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    successRate: number;
+    totalResponseTime: number;
+    averageResponseTime: number;
+    results: HttpReplayResult[];
+}
+export declare class HttpReplayService {
+    private readonly httpClient;
+    private readonly logQueryService;
+    private readonly logger;
+    constructor(httpClient: HttpClientService, logQueryService: HttpLogQueryService);
+    replayByLogId(logId: string, options?: HttpReplayOptions): Promise<HttpReplayResult>;
+    replayByRequestId(requestId: string, options?: HttpReplayOptions): Promise<HttpReplayResult>;
+    batchReplay(logIds: string[], options?: HttpReplayOptions, concurrency?: number): Promise<BatchReplayResult>;
+    batchReplayByQuery(queryOptions?: any, replayOptions?: HttpReplayOptions, concurrency?: number): Promise<BatchReplayResult>;
+    replayAndCompare(logId: string, options?: HttpReplayOptions): Promise<{
+        original: HttpLogEntity;
+        replay: HttpReplayResult;
+        comparison: {
+            statusMatch: boolean;
+            responseTimeDifference: number;
+            headersMatch: boolean;
+            bodyMatch: boolean;
+        };
+    }>;
+    private buildReplayConfig;
+    private executeReplayRequest;
+    private generateReplayId;
+    private chunkArray;
+    private compareHeaders;
+    private compareBodies;
+}