@allurereport/core 3.18.0 → 3.19.1

package/dist/config.js

@@ -91,6 +91,7 @@ export const validateConfig = (config) => {
         "historyPath",
         "historyBaseUrl",
         "historyLimit",
+        "flakyDetection",
         "resolutions",
         "plugins",
         "defaultLabels",
@@ -184,12 +185,25 @@ const resolveConfigEnvironments = (config) => {
         allowedEnvironments,
     };
 };
+const validateFlakyDetectionConfig = (config) => {
+    if (config === undefined) {
+        return;
+    }
+    const { historyDepth, includePassedTests } = config;
+    if (historyDepth !== undefined && (!Number.isInteger(historyDepth) || historyDepth < -1)) {
+        throw new Error("flakyDetection.historyDepth must be an integer greater than or equal to -1");
+    }
+    if (includePassedTests !== undefined && typeof includePassedTests !== "boolean") {
+        throw new TypeError("flakyDetection.includePassedTests must be a boolean");
+    }
+};
 export const resolveConfig = async (config, override = {}) => {
     const validationResult = validateConfig(config);
     if (!validationResult.valid) {
         throw new Error(`The provided Allure config contains unsupported fields: ${validationResult.fields.join(", ")}`);
     }
     validateResolutionsConfig(config.resolutions);
+    validateFlakyDetectionConfig(config.flakyDetection);
     const { environments, environment, allowedEnvironments } = resolveConfigEnvironments(config);
     const name = override.name ?? config.name ?? "Allure Report";
     const open = override.open ?? config.open ?? false;
@@ -246,6 +260,7 @@ export const resolveConfig = async (config, override = {}) => {
         environments,
         appendHistory,
         historyLimit,
+        flakyDetection: config.flakyDetection,
         historyPath: historyPath ? resolve(historyPath) : undefined,
         historyBaseUrl,
         dump,

package/dist/history.js

@@ -19,8 +19,8 @@ import { normalizeHistoryDataPointUrls, } from "@allurereport/core-api";
 import { isFileNotFoundError } from "./utils/misc.js";
 const createHistoryItems = (testResults, remoteUrl) => {
     return testResults
-        .filter((tr) => tr.historyId)
-        .map(({ id, name, fullName, environment, historyId, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
+        .filter((tr) => tr.retryHash)
+        .map(({ id, name, fullName, environment, retryHash, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
         return {
             id,
             name,
@@ -34,12 +34,12 @@ const createHistoryItems = (testResults, remoteUrl) => {
             duration,
             labels,
             url: remoteUrl,
-            historyId: historyId,
+            retryHash: retryHash,
             reportLinks: [],
         };
     })
         .reduce((acc, item) => {
-        acc[item.historyId] = item;
+        acc[item.retryHash] = item;
         return acc;
     }, {});
 };
@@ -228,7 +228,9 @@ export class AllureLocalHistory {
         }
         finally {
             const closing = historyFile.close();
-            dst?.destroy();
+            if (historyFile.fd !== -1) {
+                dst?.destroy();
+            }
             await closing;
             if (limit !== 0) {
                 __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").push(normalizedData);

package/dist/index.d.ts

@@ -11,4 +11,4 @@ export * from "./resolutions.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, newTestsRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/index.js

@@ -10,4 +10,4 @@ export * from "./resolutions.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, newTestsRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/qualityGate/qualityGate.js

@@ -71,7 +71,7 @@ export class QualityGate {
             }
             trsToValidateById.set(tr.id, tr);
         }
-        const trsToValidate = trsToValidateById.values().toArray();
+        const trsToValidate = [...trsToValidateById.values()];
         const { rules, use = [...qualityGateDefaultRules] } = this.config;
         const results = [];
         let fastFailed = false;

package/dist/qualityGate/rules.d.ts

@@ -7,6 +7,7 @@ type MetricRuleConfig = {
 };
 export declare const maxFailuresRule: QualityGateRule<number>;
 export declare const minTestsCountRule: QualityGateRule<number>;
+export declare const newTestsRule: QualityGateRule<boolean, number>;
 export declare const successRateRule: QualityGateRule<number>;
 export declare const maxDurationRule: QualityGateRule<number>;
 export declare const allTestsContainEnvRule: QualityGateRule<string, number>;
@@ -15,5 +16,5 @@ export declare const metricMaxRule: QualityGateRule<MetricRuleConfig>;
 export declare const metricMinRule: QualityGateRule<MetricRuleConfig>;
 export declare const metricMaxDeltaRule: QualityGateRule<MetricRuleConfig>;
 export declare const metricMaxDeltaPercentRule: QualityGateRule<MetricRuleConfig>;
-export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<string, number> | QualityGateRule<string[]> | QualityGateRule<MetricRuleConfig>)[];
+export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<boolean, number> | QualityGateRule<string, number> | QualityGateRule<string[]> | QualityGateRule<MetricRuleConfig>)[];
 export {};

package/dist/qualityGate/rules.js

@@ -41,12 +41,17 @@ const metricActual = (metrics, key, value) => {
         ...(sample?.unit ? { unit: sample.unit } : {}),
     };
 };
+const formatQualityGateNumber = (value) => {
+    if (!Number.isFinite(value)) {
+        return String(value);
+    }
+    return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(3)));
+};
 const formatMetricValue = (value, unit) => {
     if (!Number.isFinite(value)) {
         return "n/a";
     }
-    const finiteValue = value;
-    const formatted = Number.isInteger(finiteValue) ? String(finiteValue) : String(Number(finiteValue.toFixed(3)));
+    const formatted = formatQualityGateNumber(value);
     return unit ? `${formatted} ${unit}` : formatted;
 };
 const metricRuleTitle = (actual) => actual.title ?? actual.key;
@@ -101,10 +106,29 @@ export const minTestsCountRule = {
         };
     },
 };
+export const newTestsRule = {
+    rule: "newTests",
+    message: ({ actual, expected }) => expected
+        ? `No new tests were found; expected at least one new test`
+        : `The number of new tests ${bold(String(actual))} does not match the expected policy`,
+    successMessage: ({ actual }) => `New tests were found: ${bold(String(actual))}`,
+    validate: async ({ trs, expected, state }) => {
+        const previous = numberStateValue(state.getResult());
+        const newTrs = trs.filter((tr) => tr.transition === "new");
+        const testResults = newTrs.map((tr) => tr.id);
+        const actual = previous + newTrs.length;
+        state.setResult(actual, testResults);
+        return {
+            success: !expected || actual > 0,
+            actual,
+            testResults,
+        };
+    },
+};
 export const successRateRule = {
     rule: "successRate",
-    message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
-    successMessage: ({ actual, expected }) => `Success rate ${bold(String(actual))} is not less, than expected ${bold(String(expected))}`,
+    message: ({ actual, expected }) => `Success rate ${bold(formatQualityGateNumber(actual))} is less, than expected ${bold(formatQualityGateNumber(expected))}`,
+    successMessage: ({ actual, expected }) => `Success rate ${bold(formatQualityGateNumber(actual))} is not less, than expected ${bold(formatQualityGateNumber(expected))}`,
     validate: async ({ trs, expected, state }) => {
         const previous = successRateStateValue(state.getResult());
         const eligibleTrs = trs.filter(filterIncludedInSuccessRate);
@@ -232,6 +256,7 @@ export const metricMaxDeltaPercentRule = {
 export const qualityGateDefaultRules = [
     maxFailuresRule,
     minTestsCountRule,
+    newTestsRule,
     successRateRule,
     maxDurationRule,
     allTestsContainEnvRule,

package/dist/report.js

@@ -22,7 +22,7 @@ import { detect } from "@allurereport/ci";
 import { createProgressLogger } from "@allurereport/cli-commons";
 import { normalizeCategoriesConfig, parseIntegerConfigValue } from "@allurereport/core-api";
 import { AllureStoreDumpFiles, createTestResultRegistry, } from "@allurereport/plugin-api";
-import { allure1, allure2, attachments, cucumberjson, junitXml, readXcResultBundle } from "@allurereport/reader";
+import { allure1, allure2, attachments, cucumberjson, cucumberMessages, junitXml, readXcResultBundle, } from "@allurereport/reader";
 import { PathResultFile } from "@allurereport/reader-api";
 import { AllureRemoteHistory, AllureServiceClient, AllureTestOpsClient, KnownError, UnknownError, } from "@allurereport/service";
 import { generateSummary } from "@allurereport/summary";
@@ -37,7 +37,7 @@ import { writeKnownIssues } from "./resolutions.js";
 import { DefaultAllureStore } from "./store/store.js";
 import { ARTIFACTS_MANIFEST_FILENAME, createReportArtifact, deduplicateDumpInputs, } from "./utils/artifacts.js";
 import { environmentIdentityById, environmentIdentityByName } from "./utils/environment.js";
-import { getPerfMetricsResults, isPerfMetricsEnabled, measurePerf, PERF_METRIC_NAMES, PERF_METRIC_PREFIXES, perfMetricsFileName, startPerfSpan, writePerfMetrics, } from "./utils/perf.js";
+import { getPerfMetricsResults, incrementPerfCounter, isPerfMetricsEnabled, measurePerfAggregate, measurePerf, PERF_METRIC_NAMES, PERF_METRIC_PREFIXES, perfMetricsFileName, startPerfSpan, writePerfMetrics, } from "./utils/perf.js";
 import { RealtimeChannel } from "./utils/realtimeChannel.js";
 import { RealtimeUpdateScheduler } from "./utils/realtimeUpdateScheduler.js";
 import { resolveDumpAttachmentPath, UnsafeDumpPathError } from "./utils/safeDumpPath.js";
@@ -53,6 +53,11 @@ const ROOT_INTEGRATION_FILENAMES = new Set([
     QUALITY_GATE_RESULTS_FILENAME,
     ARTIFACTS_MANIFEST_FILENAME,
 ]);
+const WORKLOAD_PERF_METRIC = {
+    group: "workload",
+    groupTitle: "Workload",
+    better: "neutral",
+};
 const readConcurrency = () => {
     const parsed = Number.parseInt(process.env.ALLURE_READ_CONCURRENCY ?? "", 10);
     if (!Number.isFinite(parsed)) {
@@ -298,17 +303,23 @@ export class AllureReport {
                 throw new Error(INIT_REQUIRED_ERROR_MESSAGE);
             }
             const resultsDirPath = resolve(resultsDir);
-            if (await readXcResultBundle(__classPrivateFieldGet(this, _AllureReport_store, "f"), resultsDirPath)) {
+            if (await measurePerf(PERF_METRIC_NAMES.generateReadResultsXcresultCheck, () => readXcResultBundle(__classPrivateFieldGet(this, _AllureReport_store, "f"), resultsDirPath))) {
+                __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
                 return;
             }
             try {
-                const entries = (await readdir(resultsDirPath, { withFileTypes: true }))
+                const entries = await measurePerf(PERF_METRIC_NAMES.generateReadResultsReaddir, async () => (await readdir(resultsDirPath, { withFileTypes: true }))
                     .filter((dirent) => dirent.isFile() && !dirent.name.endsWith(".tmp"))
-                    .sort((a, b) => a.name.localeCompare(b.name));
+                    .sort((a, b) => a.name.localeCompare(b.name)));
                 const limit = pLimit(readConcurrency());
+                incrementPerfCounter(PERF_METRIC_NAMES.generateReadResultsFiles, entries.length, {
+                    ...WORKLOAD_PERF_METRIC,
+                    title: "Input files",
+                    unit: "files",
+                });
                 await Promise.all(entries.map((dirent) => limit(async () => {
                     try {
-                        const path = await realpath(join(resultsDirPath, dirent.name));
+                        const path = await measurePerfAggregate(PERF_METRIC_NAMES.generateReadResultsRealpath, () => realpath(join(resultsDirPath, dirent.name)));
                         await this.readResult(new PathResultFile(path, dirent.name));
                     }
                     catch (e) {
@@ -319,12 +330,14 @@ export class AllureReport {
             catch (e) {
                 console.error("can't read directory", e);
             }
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
         });
         this.readFile = async (resultsFile) => measurePerf(PERF_METRIC_NAMES.generateReadResults, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(INIT_REQUIRED_ERROR_MESSAGE);
             }
             await this.readResult(new PathResultFile(resultsFile));
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
         });
         this.readResult = async (data) => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
@@ -335,7 +348,7 @@ export class AllureReport {
                     if (reader.matches && !(await reader.matches(data))) {
                         continue;
                     }
-                    const processed = await reader.read(__classPrivateFieldGet(this, _AllureReport_store, "f"), data);
+                    const processed = await measurePerfAggregate(PERF_METRIC_NAMES.generateReadResultsReaderRead, () => reader.read(__classPrivateFieldGet(this, _AllureReport_store, "f"), data));
                     if (processed) {
                         return;
                     }
@@ -345,6 +358,9 @@ export class AllureReport {
         };
         this.validate = async (params) => {
             const { trs, state, environment } = params;
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "done") {
+                __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags(trs.filter(Boolean));
+            }
             const qualityGateEnvironment = environment === undefined
                 ? undefined
                 : (environmentIdentityById(__classPrivateFieldGet(this, _AllureReport_environments, "f"), environment)?.name ??
@@ -370,6 +386,7 @@ export class AllureReport {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "done") {
                 throw new Error("the report is already stopped, the restart isn't supported at the moment");
             }
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
             __classPrivateFieldSet(this, _AllureReport_executionStage, "running", "f");
             __classPrivateFieldSet(this, _AllureReport_endGeneratePerfSpan, startPerfSpan(PERF_METRIC_NAMES.generateTotal), "f");
             if (__classPrivateFieldGet(this, _AllureReport_globalAttachments, "f")?.length) {
@@ -399,6 +416,7 @@ export class AllureReport {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 return;
             }
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
                 await plugin.update?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
             });
@@ -449,7 +467,7 @@ export class AllureReport {
             const addJsonDumpEntry = async (entryName, value) => {
                 await addRequiredDumpEntry(Buffer.from(JSON.stringify(value)), entryName);
             };
-            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], metrics = [], }) => [
+            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, metadata = {}, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByRetryHash = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], metrics = [], }) => [
                 [AllureStoreDumpFiles.TestResults, testResults],
                 [AllureStoreDumpFiles.TestCases, testCases],
                 [AllureStoreDumpFiles.Fixtures, fixtures],
@@ -457,11 +475,12 @@ export class AllureReport {
                 [AllureStoreDumpFiles.CheckResults, checkResults],
                 [AllureStoreDumpFiles.Environments, environments],
                 [AllureStoreDumpFiles.ReportVariables, reportVariables],
+                [AllureStoreDumpFiles.Metadata, metadata],
                 [AllureStoreDumpFiles.ResolutionIssues, resolutionIssues],
                 [AllureStoreDumpFiles.GlobalAttachments, globalAttachmentIds],
                 [AllureStoreDumpFiles.GlobalErrors, globalErrors],
                 [AllureStoreDumpFiles.IndexAttachmentsByTestResults, indexAttachmentByTestResult],
-                [AllureStoreDumpFiles.IndexTestResultsByHistoryId, indexTestResultByHistoryId],
+                [AllureStoreDumpFiles.IndexTestResultsByRetryHash, indexTestResultByRetryHash],
                 [AllureStoreDumpFiles.IndexTestResultsByTestCase, indexTestResultByTestCase],
                 [AllureStoreDumpFiles.IndexTestResultsByResolutionIssue, indexTestResultByResolutionIssue],
                 [AllureStoreDumpFiles.IndexAttachmentsByFixture, indexAttachmentByFixture],
@@ -537,6 +556,7 @@ export class AllureReport {
         this.restoreState = async (dumps) => {
             __classPrivateFieldGet(this, _AllureReport_store, "f").resetIngestOrder();
             await __classPrivateFieldGet(this, _AllureReport_restoreStateDumps, "f").call(this, dumps.map((path) => ({ artifactPath: path, path })));
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
         };
         _AllureReport_recordArtifact.set(this, (filePath, name = basename(filePath)) => {
             const artifact = createReportArtifact(filePath, __classPrivateFieldGet(this, _AllureReport_getCwd, "f").call(this), name);
@@ -604,11 +624,10 @@ export class AllureReport {
                             const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
                             const environmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Environments);
                             const reportVariablesEntry = await requiredEntryData(AllureStoreDumpFiles.ReportVariables);
+                            const metadataEntry = await optionalEntryData(AllureStoreDumpFiles.Metadata);
                             const globalAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalAttachments);
                             const globalErrorsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalErrors);
                             const indexAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
-                            const indexTestResultsByHistoryId = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
-                            const indexTestResultsByTestCaseEntry = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
                             const indexTestResultsByResolutionIssueEntry = await optionalEntryData(AllureStoreDumpFiles.IndexTestResultsByResolutionIssue);
                             const indexAttachmentsByFixtureEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
                             const indexFixturesByTestResultEntry = await requiredEntryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
@@ -626,11 +645,12 @@ export class AllureReport {
                                     case AllureStoreDumpFiles.Fixtures:
                                     case AllureStoreDumpFiles.Environments:
                                     case AllureStoreDumpFiles.ReportVariables:
+                                    case AllureStoreDumpFiles.Metadata:
                                     case AllureStoreDumpFiles.ResolutionIssues:
                                     case AllureStoreDumpFiles.GlobalAttachments:
                                     case AllureStoreDumpFiles.GlobalErrors:
                                     case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
-                                    case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
+                                    case AllureStoreDumpFiles.IndexTestResultsByRetryHash:
                                     case AllureStoreDumpFiles.IndexTestResultsByTestCase:
                                     case AllureStoreDumpFiles.IndexTestResultsByResolutionIssue:
                                     case AllureStoreDumpFiles.IndexAttachmentsByFixture:
@@ -656,11 +676,12 @@ export class AllureReport {
                                 checkResults: checkResultsEntry ? JSON.parse(checkResultsEntry.toString("utf8")) : [],
                                 environments: JSON.parse(environmentsEntry.toString("utf8")),
                                 reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
+                                metadata: metadataEntry ? JSON.parse(metadataEntry.toString("utf8")) : {},
                                 globalAttachmentIds: JSON.parse(globalAttachmentsEntry.toString("utf8")),
                                 globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
                                 indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
-                                indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
-                                indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
+                                indexTestResultByRetryHash: {},
+                                indexTestResultByTestCase: {},
                                 indexTestResultByResolutionIssue: indexTestResultsByResolutionIssueEntry
                                     ? JSON.parse(indexTestResultsByResolutionIssueEntry.toString("utf8"))
                                     : {},
@@ -840,6 +861,7 @@ export class AllureReport {
                     console.error("realtime update failed during shutdown", e);
                 }
                 __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
+                __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
                 if (__classPrivateFieldGet(this, _AllureReport_dump, "f")) {
                     await this.dumpState();
                     return;
@@ -970,6 +992,11 @@ export class AllureReport {
                     await pluginState.set("files", {});
                 }
                 const pluginFiles = new PluginFiles(__classPrivateFieldGet(this, _AllureReport_reportFiles, "f"), id, async (key, filepath) => {
+                    incrementPerfCounter(`${PERF_METRIC_PREFIXES.generatePlugin}${id}.generatedFiles`, 1, {
+                        ...WORKLOAD_PERF_METRIC,
+                        title: `Generated ${id} files`,
+                        unit: "files",
+                    });
                     const currentPluginState = __classPrivateFieldGet(this, _AllureReport_instances, "m", _AllureReport_getPluginState).call(this, false, id);
                     const files = await currentPluginState?.get("files");
                     if (!files) {
@@ -986,6 +1013,14 @@ export class AllureReport {
                     hideLabels: __classPrivateFieldGet(this, _AllureReport_hideLabels, "f"),
                     state: pluginState,
                     reportFiles: pluginFiles,
+                    ...(isPerfMetricsEnabled()
+                        ? {
+                            perf: {
+                                measure: (name, fn) => measurePerf(`${PERF_METRIC_PREFIXES.generatePlugin}${id}.${name}`, fn),
+                                count: (name, value, metadata) => incrementPerfCounter(`${PERF_METRIC_PREFIXES.generatePlugin}${id}.${name}`, value, metadata),
+                            },
+                        }
+                        : {}),
                     reportUrl: this.reportUrl,
                     realTime: !!__classPrivateFieldGet(this, _AllureReport_realTime, "f"),
                     output: __classPrivateFieldGet(this, _AllureReport_output, "f"),
@@ -1005,7 +1040,7 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyBaseUrl, historyLimit, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, performance, dump, categories, allureService, globalAttachments, cwd, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, cucumberMessages, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyBaseUrl, historyLimit, flakyDetection, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, performance, dump, categories, allureService, globalAttachments, cwd, } = opts;
         const allureServiceAccessToken = allureService?.accessToken;
         if (allureServiceAccessToken) {
             const allureServiceClientConfig = {
@@ -1024,7 +1059,11 @@ export class AllureReport {
         __classPrivateFieldSet(this, _AllureReport_ci, detect(), "f");
         const reportTitleSuffix = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestName ?? __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunName;
         this.reportName = [name, reportTitleSuffix].filter(Boolean).join(" – ");
-        __classPrivateFieldSet(this, _AllureReport_realtimeChannel, new RealtimeChannel(), "f");
+        __classPrivateFieldSet(this, _AllureReport_realtimeChannel, new RealtimeChannel(() => {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "running") {
+                __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
+            }
+        }), "f");
         __classPrivateFieldSet(this, _AllureReport_realtimeUpdateScheduler, new RealtimeUpdateScheduler(__classPrivateFieldGet(this, _AllureReport_runRealtimeUpdate, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
         __classPrivateFieldSet(this, _AllureReport_dump, dump, "f");
@@ -1057,6 +1096,7 @@ export class AllureReport {
             reportVariables: variables,
             environmentsConfig: environments,
             history: __classPrivateFieldGet(this, _AllureReport_history, "f"),
+            flakyDetection,
             resolutionsConfig: resolutions,
             defaultLabels,
             environment,

package/dist/store/convert.d.ts

@@ -1,6 +1,5 @@
 import type { AttachmentLink, TestCase, TestFixtureResult, TestResult } from "@allurereport/core-api";
 import type { RawFixtureResult, RawTestResult, ReaderContext } from "@allurereport/reader-api";
-export declare const __unknown = "#___unknown_value___#";
 export type StateData = {
     testCases: Map<string, TestCase>;
     attachments: Map<string, AttachmentLink>;