@allurereport/plugin-testops 3.15.0 → 3.16.1

package/dist/plugin.js

@@ -9,39 +9,50 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _TestOpsPlugin_instances, _TestOpsPlugin_logger, _TestOpsPlugin_ci, _TestOpsPlugin_client, _TestOpsPlugin_launchName, _TestOpsPlugin_launchTags, _TestOpsPlugin_uploadedTestResultsIds, _TestOpsPlugin_autocloseLaunch, _TestOpsPlugin_launchStarted, _TestOpsPlugin_gitFlow, _TestOpsPlugin_enabledByConfig, _TestOpsPlugin_uploadQualityGateResults, _TestOpsPlugin_uploadGlobalErrors, _TestOpsPlugin_uploadGlobalAttachments, _TestOpsPlugin_uploadTestResults, _TestOpsPlugin_upload, _TestOpsPlugin_trsToUpload, _TestOpsPlugin_enrichWithCategories, _TestOpsPlugin_syncLaunchCategories, _TestOpsPlugin_collectCategoryNamesByExternalId, _TestOpsPlugin_assignCreatedCategoryIds, _TestOpsPlugin_startUpload, _TestOpsPlugin_stopUpload;
+var _TestOpsPlugin_instances, _TestOpsPlugin_logger, _TestOpsPlugin_ci, _TestOpsPlugin_client, _TestOpsPlugin_launchName, _TestOpsPlugin_launchTags, _TestOpsPlugin_uploadedTestResultsIds, _TestOpsPlugin_uploadedGlobalAttachmentIds, _TestOpsPlugin_uploadedGlobalErrors, _TestOpsPlugin_autocloseLaunch, _TestOpsPlugin_launchStarted, _TestOpsPlugin_reopenClosedLaunch, _TestOpsPlugin_skippedUploadCycle, _TestOpsPlugin_launchId, _TestOpsPlugin_gitFlow, _TestOpsPlugin_enabledByConfig, _TestOpsPlugin_uploadQueue, _TestOpsPlugin_reopenLaunchIfClosed, _TestOpsPlugin_logDeferredUpload, _TestOpsPlugin_retryHooks, _TestOpsPlugin_logUploadFailure, _TestOpsPlugin_uploadQualityGateResults, _TestOpsPlugin_uploadGlobalErrors, _TestOpsPlugin_uploadGlobalAttachments, _TestOpsPlugin_uploadTestResults, _TestOpsPlugin_upload, _TestOpsPlugin_trsToUpload, _TestOpsPlugin_startUpload, _TestOpsPlugin_stopUpload;
 import { env } from "node:process";
-import { detect, isLocalCiDescriptor } from "@allurereport/ci";
+import { applyAllureCiEnv, detect, isLocalCiDescriptor } from "@allurereport/ci";
 import { createProgressLogger } from "@allurereport/cli-commons";
 import { getWorstStatus } from "@allurereport/core-api";
 import { createPluginSummary, } from "@allurereport/plugin-api";
 import { uniqBy, stubTrue } from "lodash-es";
 import { bold } from "yoctocolors";
 import { TestOpsClient } from "./client.js";
+import { isClosedLaunchError } from "./errors.js";
 import { LaunchGitFlow, resolveGitFlowOptions } from "./gitFlow/index.js";
 import { Logger } from "./logger.js";
+import { UploadQueue } from "./uploadQueue.js";
 import { uploadFilenameForLink } from "./utils/attachments.js";
-import { toUploadCategory } from "./utils/categories.js";
-import { resolvePluginOptions } from "./utils/options.js";
-import { attachmentsResolverFactory, fixturesResolverFactory, unwrapStepsAttachments } from "./utils/resolvers.js";
+import { applyCiOverrides } from "./utils/ciOverrides.js";
+import { enrichWithCategories, syncLaunchCategories } from "./utils/launchCategories.js";
+import { resolvePluginOptions, toPositiveInteger } from "./utils/options.js";
+import { attachmentsResolverFactory, fixturesResolverFactory } from "./utils/resolvers.js";
 import { validateExecutableName } from "./utils/validation.js";
 const LAUNCH_PROGRESS_POLL_DELAY_MS = 500;
 const LAUNCH_PROGRESS_ATTEMPTS_LIMIT = 10;
-const categoryDisplayName = (cat) => cat.name ?? cat.grouping?.[0]?.name ?? cat.grouping?.[0]?.value ?? cat.grouping?.[0]?.key ?? cat.externalId;
+const resolveJobRunIdFromEnv = () => toPositiveInteger(env.ALLURE_JOB_RUN_ID);
 export class TestOpsPlugin {
     constructor(options, context = {}) {
         _TestOpsPlugin_instances.add(this);
         this.options = options;
         _TestOpsPlugin_logger.set(this, new Logger("TestOpsPlugin"));
-        _TestOpsPlugin_ci.set(this, detect());
+        _TestOpsPlugin_ci.set(this, void 0);
         _TestOpsPlugin_client.set(this, void 0);
         _TestOpsPlugin_launchName.set(this, "");
         _TestOpsPlugin_launchTags.set(this, []);
         _TestOpsPlugin_uploadedTestResultsIds.set(this, new Set());
+        _TestOpsPlugin_uploadedGlobalAttachmentIds.set(this, new Set());
+        _TestOpsPlugin_uploadedGlobalErrors.set(this, new Set());
         _TestOpsPlugin_autocloseLaunch.set(this, false);
         _TestOpsPlugin_launchStarted.set(this, false);
+        _TestOpsPlugin_reopenClosedLaunch.set(this, false);
+        _TestOpsPlugin_skippedUploadCycle.set(this, false);
+        _TestOpsPlugin_launchId.set(this, void 0);
         _TestOpsPlugin_gitFlow.set(this, void 0);
         _TestOpsPlugin_enabledByConfig.set(this, false);
+        _TestOpsPlugin_uploadQueue.set(this, new UploadQueue());
+        applyAllureCiEnv();
+        __classPrivateFieldSet(this, _TestOpsPlugin_ci, applyCiOverrides(detect()), "f");
         __classPrivateFieldSet(this, _TestOpsPlugin_enabledByConfig, context.enabled === true, "f");
         if (context.enabled === false) {
             return;
@@ -50,17 +61,20 @@ export class TestOpsPlugin {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`plugin is disabled - no CI environment detected. To enable, set ${bold("ALLURE_TESTOPS_ENABLED")}=true or ${bold("CI")}=true.`);
             return;
         }
-        const { accessToken, endpoint, projectId, launchName, launchTags, autocloseLaunch = true, } = resolvePluginOptions(options);
+        const { accessToken, endpoint, projectId, launchName, launchTags, autocloseLaunch = true, uploadRateLimit, reopenClosedLaunch = false, launchId, } = resolvePluginOptions(options);
         if ([accessToken, endpoint, projectId].every(Boolean)) {
             __classPrivateFieldSet(this, _TestOpsPlugin_client, new TestOpsClient({
                 baseUrl: endpoint,
                 accessToken,
                 projectId,
+                uploadRateLimit,
             }), "f");
             __classPrivateFieldSet(this, _TestOpsPlugin_launchName, launchName, "f");
             __classPrivateFieldSet(this, _TestOpsPlugin_launchTags, launchTags, "f");
         }
         __classPrivateFieldSet(this, _TestOpsPlugin_autocloseLaunch, autocloseLaunch, "f");
+        __classPrivateFieldSet(this, _TestOpsPlugin_reopenClosedLaunch, reopenClosedLaunch, "f");
+        __classPrivateFieldSet(this, _TestOpsPlugin_launchId, launchId, "f");
         const gitFlowOptions = resolveGitFlowOptions(options);
         __classPrivateFieldSet(this, _TestOpsPlugin_gitFlow, new LaunchGitFlow({
             ci: __classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"),
@@ -85,7 +99,7 @@ export class TestOpsPlugin {
             }
             return ["true", "1"].includes(value);
         };
-        return isEnabled(env.ALLURE_TESTOPS_ENABLED) || isEnabled(env.CI);
+        return isEnabled(env.ALLURE_TESTOPS_ENABLED) || isEnabled(env.CI) || resolveJobRunIdFromEnv() !== undefined;
     }
     get isManuallyEnabled() {
         return __classPrivateFieldGet(this, _TestOpsPlugin_enabledByConfig, "f") || this.isOverridenByEnv;
@@ -106,6 +120,9 @@ export class TestOpsPlugin {
         if (!this.enabled) {
             return;
         }
+        if (context.realTime) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").setLogLevel("info");
+        }
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Starting upload…");
         if (!(await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_startUpload).call(this))) {
             return;
@@ -139,6 +156,15 @@ export class TestOpsPlugin {
         const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Finalizing upload…");
         await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_upload).call(this, store, { context, stage: "done" });
+        const stillPending = await __classPrivateFieldGet(this, _TestOpsPlugin_uploadQueue, "f").flush({
+            onRetry: async (error, attempt) => {
+                __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(`Retrying deferred TestOps upload at finalization (attempt ${attempt}): ${error}`);
+                await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_reopenLaunchIfClosed).call(this, error);
+            },
+        });
+        if (stillPending.length > 0) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`${stillPending.length} TestOps upload(s) could not be completed after retrying at finalization: ${stillPending.join(", ")}`);
+        }
         try {
             await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_stopUpload).call(this, worstStatus || "unknown");
         }
@@ -162,6 +188,10 @@ export class TestOpsPlugin {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Upload finished. Allure TestOps Launch: ${__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchUrl}`);
             return;
         }
+        if (stillPending.length > 0 || __classPrivateFieldGet(this, _TestOpsPlugin_skippedUploadCycle, "f")) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Not closing launch ${launchId}: some uploads never made it to TestOps, closing now would report an incomplete launch as finished.`);
+            return;
+        }
         let launchIsReady = false;
         for (let attempt = 0; attempt < LAUNCH_PROGRESS_ATTEMPTS_LIMIT; attempt += 1) {
             launchIsReady = await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").checkLaunchProgress();
@@ -209,7 +239,45 @@ export class TestOpsPlugin {
         return summary;
     }
 }
-_TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestOpsPlugin_client = new WeakMap(), _TestOpsPlugin_launchName = new WeakMap(), _TestOpsPlugin_launchTags = new WeakMap(), _TestOpsPlugin_uploadedTestResultsIds = new WeakMap(), _TestOpsPlugin_autocloseLaunch = new WeakMap(), _TestOpsPlugin_launchStarted = new WeakMap(), _TestOpsPlugin_gitFlow = new WeakMap(), _TestOpsPlugin_enabledByConfig = new WeakMap(), _TestOpsPlugin_instances = new WeakSet(), _TestOpsPlugin_uploadQualityGateResults = async function _TestOpsPlugin_uploadQualityGateResults(store) {
+_TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestOpsPlugin_client = new WeakMap(), _TestOpsPlugin_launchName = new WeakMap(), _TestOpsPlugin_launchTags = new WeakMap(), _TestOpsPlugin_uploadedTestResultsIds = new WeakMap(), _TestOpsPlugin_uploadedGlobalAttachmentIds = new WeakMap(), _TestOpsPlugin_uploadedGlobalErrors = new WeakMap(), _TestOpsPlugin_autocloseLaunch = new WeakMap(), _TestOpsPlugin_launchStarted = new WeakMap(), _TestOpsPlugin_reopenClosedLaunch = new WeakMap(), _TestOpsPlugin_skippedUploadCycle = new WeakMap(), _TestOpsPlugin_launchId = new WeakMap(), _TestOpsPlugin_gitFlow = new WeakMap(), _TestOpsPlugin_enabledByConfig = new WeakMap(), _TestOpsPlugin_uploadQueue = new WeakMap(), _TestOpsPlugin_instances = new WeakSet(), _TestOpsPlugin_reopenLaunchIfClosed = async function _TestOpsPlugin_reopenLaunchIfClosed(error) {
+    if (!__classPrivateFieldGet(this, _TestOpsPlugin_reopenClosedLaunch, "f") || !isClosedLaunchError(error)) {
+        return;
+    }
+    const launchId = __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchId;
+    if (launchId === undefined) {
+        return;
+    }
+    try {
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Launch ${launchId} was closed - reopening before retrying the upload…`);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").reopenLaunch(launchId);
+    }
+    catch (reopenError) {
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(`Failed to reopen launch ${launchId}: ${reopenError}`);
+    }
+}, _TestOpsPlugin_logDeferredUpload = function _TestOpsPlugin_logDeferredUpload(label, error) {
+    __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(error
+        ? `TestOps upload is unavailable; ${label} will be retried during finalization. Reason: ${error}`
+        : `TestOps upload is suspended; ${label} will be retried during finalization.`);
+}, _TestOpsPlugin_retryHooks = function _TestOpsPlugin_retryHooks(label) {
+    return {
+        onRetry: async (error, attempt) => {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(`Retrying ${label} upload (attempt ${attempt}): ${error}`);
+            await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_reopenLaunchIfClosed).call(this, error);
+        },
+        onDeferred: (error) => __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_logDeferredUpload).call(this, label, error),
+    };
+}, _TestOpsPlugin_logUploadFailure = function _TestOpsPlugin_logUploadFailure(label, error) {
+    if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload ${label}: ${error.response.data.message}`);
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
+    }
+    else if (error instanceof Error) {
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload ${label}: ${error.message}`);
+    }
+    else {
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload ${label}`);
+    }
+}, _TestOpsPlugin_uploadQualityGateResults = async function _TestOpsPlugin_uploadQualityGateResults(store) {
     const results = await store.qualityGateResults();
     const uniqueResults = uniqBy(results.filter(({ success }) => !success), ({ rule, environment }) => `${rule}-${environment}`);
     if (uniqueResults.length === 0) {
@@ -225,36 +293,29 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
     let completed = false;
     try {
         progressLogger.log(true);
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadQualityGateResults(uniqueResults, (percent) => {
+        const result = await __classPrivateFieldGet(this, _TestOpsPlugin_uploadQueue, "f").run("quality-gate", () => __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadQualityGateResults(uniqueResults, (percent) => {
             if (!completed && percent >= 100) {
                 completed = true;
                 progressLogger.increment();
             }
-        });
+        }), __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_retryHooks).call(this, "quality gate results"));
+        if (result.deferred) {
+            return;
+        }
         if (!completed) {
             progressLogger.increment();
         }
         progressLogger.log(true);
     }
     catch (error) {
-        if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload quality gate results: ${error.response.data.message}`);
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
-        }
-        else if (error instanceof Error) {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload quality gate results: ${error.message}`);
-        }
-        else {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload quality gate results");
-        }
+        __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_logUploadFailure).call(this, "quality gate results", error);
     }
     finally {
         progressLogger.cancel?.();
     }
-}, _TestOpsPlugin_uploadGlobalErrors = async function _TestOpsPlugin_uploadGlobalErrors(store) {
-    const results = await store.allGlobalErrors();
+}, _TestOpsPlugin_uploadGlobalErrors = async function _TestOpsPlugin_uploadGlobalErrors(results) {
     if (results.length === 0) {
-        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("No global errors to upload");
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("No new global errors to upload");
         return;
     }
     const progressLogger = createProgressLogger({
@@ -266,36 +327,32 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
     let completed = false;
     try {
         progressLogger.log(true);
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalErrors(results, (percent) => {
+        const result = await __classPrivateFieldGet(this, _TestOpsPlugin_uploadQueue, "f").run("global-errors", () => __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalErrors(results, (percent) => {
             if (!completed && percent >= 100) {
                 completed = true;
                 progressLogger.increment();
             }
-        });
+        }), __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_retryHooks).call(this, "global errors"));
+        if (result.deferred) {
+            return;
+        }
         if (!completed) {
             progressLogger.increment();
         }
+        results.forEach((error) => {
+            __classPrivateFieldGet(this, _TestOpsPlugin_uploadedGlobalErrors, "f").add(error);
+        });
         progressLogger.log(true);
     }
     catch (error) {
-        if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload global errors: ${error.response.data.message}`);
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
-        }
-        else if (error instanceof Error) {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload global errors: ${error.message}`);
-        }
-        else {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload global errors");
-        }
+        __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_logUploadFailure).call(this, "global errors", error);
     }
     finally {
         progressLogger.cancel?.();
     }
-}, _TestOpsPlugin_uploadGlobalAttachments = async function _TestOpsPlugin_uploadGlobalAttachments(store) {
-    const attachments = await store.allGlobalAttachments();
+}, _TestOpsPlugin_uploadGlobalAttachments = async function _TestOpsPlugin_uploadGlobalAttachments(store, attachments) {
     if (attachments.length === 0) {
-        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug("No global attachments to upload");
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug("No new global attachments to upload");
         return;
     }
     const progressLogger = createProgressLogger({
@@ -307,7 +364,7 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
     let completed = false;
     try {
         progressLogger.log(true);
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalAttachments({
+        const result = await __classPrivateFieldGet(this, _TestOpsPlugin_uploadQueue, "f").run("global-attachments", () => __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalAttachments({
             attachments,
             attachmentsResolver: async (attachmentLink) => {
                 const content = await store.attachmentContentById(attachmentLink.id);
@@ -320,6 +377,7 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
                     originalFileName: filename,
                     contentType: attachmentLink.contentType ?? "application/octet-stream",
                     content: body,
+                    contentLength: content?.getContentLength(),
                 };
             },
             onProgress: (percent) => {
@@ -328,77 +386,102 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
                     progressLogger.increment();
                 }
             },
-        });
+        }), __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_retryHooks).call(this, "global attachments"));
+        if (result.deferred) {
+            return;
+        }
         if (!completed) {
             progressLogger.increment();
         }
+        attachments.forEach((attachment) => {
+            __classPrivateFieldGet(this, _TestOpsPlugin_uploadedGlobalAttachmentIds, "f").add(attachment.id);
+        });
         progressLogger.log(true);
     }
     catch (error) {
-        if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload global attachments: ${error.response.data.message}`);
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
-        }
-        else if (error instanceof Error) {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload global attachments: ${error.message}`);
-        }
-        else {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload global attachments");
-        }
+        __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_logUploadFailure).call(this, "global attachments", error);
     }
     finally {
         progressLogger.cancel?.();
     }
-}, _TestOpsPlugin_uploadTestResults = async function _TestOpsPlugin_uploadTestResults(store, trsToUpload, environments) {
+}, _TestOpsPlugin_uploadTestResults = async function _TestOpsPlugin_uploadTestResults(store, trsToUpload, environments, options) {
     const totalCount = trsToUpload.length;
-    __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Preparing to upload ${bold(totalCount.toString())} ${totalCount > 1 ? "test results" : "test result"}`);
+    __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose(`Preparing to upload ${bold(totalCount.toString())} ${totalCount > 1 ? "test results" : "test result"}`);
     const progressLogger = createProgressLogger({
         total: totalCount,
         message: "Uploading test results",
         unitLabel: totalCount === 1 ? "test result uploaded" : "test results uploaded",
         prefix: "[TestOpsPlugin]",
+        silent: !!options?.silent,
     });
-    const logProgress = progressLogger.log;
-    const incrementProgress = progressLogger.increment;
     try {
-        logProgress(true);
-        const uploadedTrs = await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadTestResults({
+        progressLogger.log(true);
+        const { onRetry, onDeferred } = __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_retryHooks).call(this, "test results");
+        const result = await __classPrivateFieldGet(this, _TestOpsPlugin_uploadQueue, "f").run("test-results", () => __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadTestResults({
             attachmentsResolver: attachmentsResolverFactory(store),
             fixturesResolver: fixturesResolverFactory(store),
             environments,
-            trs: trsToUpload,
-            onProgress: () => incrementProgress(),
-        });
-        logProgress(true);
+            trs: trsToUpload.filter((tr) => !__classPrivateFieldGet(this, _TestOpsPlugin_uploadedTestResultsIds, "f").has(tr.id)),
+            onProgress: () => progressLogger.increment(),
+            onRetry,
+            onChunkUploaded: (uploadedChunkTrs) => {
+                uploadedChunkTrs.forEach((tr) => __classPrivateFieldGet(this, _TestOpsPlugin_uploadedTestResultsIds, "f").add(tr.id));
+            },
+        }), { onRetry, onDeferred });
+        if (result.deferred) {
+            return;
+        }
+        const uploadedTrs = result.value;
+        progressLogger.log(true);
         uploadedTrs.forEach((tr) => {
             __classPrivateFieldGet(this, _TestOpsPlugin_uploadedTestResultsIds, "f").add(tr.id);
         });
         const uploadedCount = uploadedTrs.length;
         if (uploadedCount === 0) {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn("No test results were uploaded");
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("No test results were uploaded");
             return;
         }
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Uploaded ${uploadedCount} ${uploadedCount > 1 ? "test results" : "test result"}`);
     }
+    catch (error) {
+        __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_logUploadFailure).call(this, "test results", error);
+    }
     finally {
         progressLogger.cancel?.();
     }
 }, _TestOpsPlugin_upload = async function _TestOpsPlugin_upload(store, options = {}) {
     const { context, stage } = options;
     const trsToUpload = await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_trsToUpload).call(this, store);
+    const shouldUploadGlobalArtifacts = stage === "done" || !context?.realTime;
+    let globalErrors = [];
+    let globalAttachments = [];
+    if (shouldUploadGlobalArtifacts) {
+        const [allGlobalErrors, allGlobalAttachments] = await Promise.all([
+            store.allGlobalErrors(),
+            store.allGlobalAttachments(),
+        ]);
+        globalErrors = allGlobalErrors.filter((error) => !__classPrivateFieldGet(this, _TestOpsPlugin_uploadedGlobalErrors, "f").has(error));
+        globalAttachments = allGlobalAttachments.filter((attachment) => !__classPrivateFieldGet(this, _TestOpsPlugin_uploadedGlobalAttachmentIds, "f").has(attachment.id));
+    }
     if (trsToUpload.length === 0) {
         if (stage == "update") {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info("No new test results to upload");
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("No new test results to upload");
         }
         if (stage === "done") {
-            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info("No test results to upload");
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("No test results to upload");
         }
-        return;
+        if (globalErrors.length === 0 && globalAttachments.length === 0) {
+            return;
+        }
+    }
+    if (stage === "update" && trsToUpload.length > 0) {
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose(`Found ${bold(trsToUpload.length.toString())} new test ${trsToUpload.length > 1 ? "results" : "result"}, uploading…`);
     }
     try {
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createSession(env);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createSession(env, __classPrivateFieldGet(this, _TestOpsPlugin_reopenClosedLaunch, "f"));
     }
     catch (error) {
+        __classPrivateFieldSet(this, _TestOpsPlugin_skippedUploadCycle, true, "f");
         if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to create TestOps session: ${error.response.data.message}`);
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
@@ -411,14 +494,23 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
         }
         return;
     }
-    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadGlobalAttachments).call(this, store);
-    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadGlobalErrors).call(this, store);
+    __classPrivateFieldSet(this, _TestOpsPlugin_skippedUploadCycle, false, "f");
+    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadGlobalAttachments).call(this, store, globalAttachments);
+    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadGlobalErrors).call(this, globalErrors);
+    if (trsToUpload.length === 0) {
+        return;
+    }
     await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadQualityGateResults).call(this, store);
     const environments = await store.allEnvironmentIdentities();
     const contextCategories = context?.categories ?? [];
-    const trsEnrichedWithCategories = await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_enrichWithCategories).call(this, store, trsToUpload, contextCategories);
-    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_syncLaunchCategories).call(this, trsEnrichedWithCategories, contextCategories);
-    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadTestResults).call(this, store, trsEnrichedWithCategories, environments);
+    const trsEnrichedWithCategories = await enrichWithCategories(store, trsToUpload, contextCategories);
+    const categoriesError = await syncLaunchCategories(__classPrivateFieldGet(this, _TestOpsPlugin_client, "f"), trsEnrichedWithCategories, contextCategories);
+    if (categoriesError) {
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Uploading test results without launch categories: ${categoriesError.message}`);
+    }
+    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadTestResults).call(this, store, trsEnrichedWithCategories, environments, {
+        silent: !!context?.realTime,
+    });
 }, _TestOpsPlugin_trsToUpload = async function _TestOpsPlugin_trsToUpload(store) {
     const filter = this.options.filter ?? stubTrue;
     const filteredTrs = await store.allTestResults({
@@ -432,96 +524,19 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
         includeRetries: false,
     });
     return filteredTrs;
-}, _TestOpsPlugin_enrichWithCategories = async function _TestOpsPlugin_enrichWithCategories(store, trs, contextCategories) {
-    return Promise.all(trs.map(async (tr) => {
-        const environmentId = await store.environmentIdByTrId(tr.id);
-        const base = {
-            ...tr,
-            ...(environmentId ? { environment: environmentId } : {}),
-            steps: unwrapStepsAttachments(tr.steps),
-        };
-        const category = toUploadCategory(base, contextCategories ?? []);
-        if (category) {
-            base.category = category;
-        }
-        return base;
-    }));
-}, _TestOpsPlugin_syncLaunchCategories = async function _TestOpsPlugin_syncLaunchCategories(trs, contextCategories) {
-    const categoryNamesByExternalId = __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_collectCategoryNamesByExternalId).call(this, trs);
-    if (categoryNamesByExternalId.size === 0) {
-        return;
-    }
-    const bulkItems = [];
-    const seenExternalIds = new Set();
-    for (const tr of trs) {
-        const cat = tr.category;
-        if (!cat?.externalId)
-            continue;
-        if (seenExternalIds.has(cat.externalId))
-            continue;
-        seenExternalIds.add(cat.externalId);
-        bulkItems.push({
-            externalId: cat.externalId,
-            name: categoryNamesByExternalId.get(cat.externalId) ?? categoryDisplayName(cat),
-            hide: cat.hide,
-            expand: cat.expand,
-        });
-    }
-    const rankByExternalId = new Map();
-    for (const c of contextCategories) {
-        if (!rankByExternalId.has(c.id)) {
-            rankByExternalId.set(c.id, c.index);
-        }
-        if (!rankByExternalId.has(c.name)) {
-            rankByExternalId.set(c.name, c.index);
-        }
-    }
-    const ranked = bulkItems.map((item, i) => ({
-        item,
-        i,
-        rank: rankByExternalId.get(item.externalId),
-    }));
-    ranked.sort((a, b) => {
-        const ar = a.rank ?? Number.POSITIVE_INFINITY;
-        const br = b.rank ?? Number.POSITIVE_INFINITY;
-        if (ar !== br)
-            return ar - br;
-        return a.i - b.i;
-    });
-    const orderedBulkItems = ranked.map((r) => r.item);
-    const launchId = __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchId;
-    try {
-        const created = await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunchCategoriesBulk(launchId, orderedBulkItems);
-        const categoryIdByExternalId = new Map(created.map((r) => [r.externalId, r.id]));
-        __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_assignCreatedCategoryIds).call(this, trs, categoryIdByExternalId);
-    }
-    catch {
-    }
-}, _TestOpsPlugin_collectCategoryNamesByExternalId = function _TestOpsPlugin_collectCategoryNamesByExternalId(trs) {
-    const map = new Map();
-    for (const tr of trs) {
-        const cat = tr.category;
-        if (cat?.externalId) {
-            map.set(cat.externalId, categoryDisplayName(cat));
-        }
-    }
-    return map;
-}, _TestOpsPlugin_assignCreatedCategoryIds = function _TestOpsPlugin_assignCreatedCategoryIds(trs, idByExternalId) {
-    for (const tr of trs) {
-        const cat = tr.category;
-        if (!cat?.externalId) {
-            continue;
-        }
-        const id = idByExternalId.get(cat.externalId);
-        if (typeof id === "number") {
-            tr.category = { ...cat, id };
-        }
-    }
 }, _TestOpsPlugin_startUpload = async function _TestOpsPlugin_startUpload() {
-    const launchGitContext = __classPrivateFieldGet(this, _TestOpsPlugin_gitFlow, "f").resolve();
+    const jobRunId = resolveJobRunIdFromEnv();
     try {
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestOpsPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestOpsPlugin_launchTags, "f"), launchGitContext);
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").startUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"));
+        if (!jobRunId) {
+            if (__classPrivateFieldGet(this, _TestOpsPlugin_launchId, "f") !== undefined) {
+                __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").attachToLaunch(__classPrivateFieldGet(this, _TestOpsPlugin_launchId, "f"));
+            }
+            else {
+                const launchGitContext = __classPrivateFieldGet(this, _TestOpsPlugin_gitFlow, "f").resolve();
+                await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestOpsPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestOpsPlugin_launchTags, "f"), launchGitContext);
+            }
+        }
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").startUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"), jobRunId);
         __classPrivateFieldSet(this, _TestOpsPlugin_launchStarted, true, "f");
     }
     catch (error) {

package/dist/uploadPacer.d.ts

@@ -0,0 +1,12 @@
+import type { UploadRateLimit } from "./model.js";
+export type UploadCost = {
+    requests?: number;
+    files?: number;
+    bytes?: number;
+};
+export declare const DEFAULT_UPLOAD_RATE_LIMIT: UploadRateLimit;
+export declare class UploadPacer {
+    #private;
+    constructor(rateLimit: UploadRateLimit | false | undefined, now?: () => number);
+    wait(cost: UploadCost, signal?: AbortSignal): Promise<void>;
+}

package/dist/uploadPacer.js

@@ -0,0 +1,76 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _UploadPacer_instances, _UploadPacer_requests, _UploadPacer_files, _UploadPacer_bytes, _UploadPacer_now, _UploadPacer_reserve, _UploadPacer_reserveAt;
+import { setTimeout as delay } from "node:timers/promises";
+export const DEFAULT_UPLOAD_RATE_LIMIT = {
+    windowMs: 1000,
+    maxRequestsPerWindow: 20,
+    maxFilesPerWindow: 1000,
+    maxBytesPerWindow: 1024 * 1024 * 1024,
+};
+const isBudgetEnabled = (budget) => budget.windowMs > 0 && budget.limit > 0;
+const scaledWindowCost = (windowMs, cost, limit) => {
+    if (windowMs <= 0 || cost <= 0 || limit <= 0) {
+        return 0;
+    }
+    return (windowMs * cost) / limit;
+};
+const resolveRateLimit = (rateLimit) => {
+    const rateLimitUnset = rateLimit === undefined;
+    const rateLimitDisabled = rateLimit === false;
+    if (rateLimitUnset) {
+        return DEFAULT_UPLOAD_RATE_LIMIT;
+    }
+    if (rateLimitDisabled) {
+        return undefined;
+    }
+    return rateLimit;
+};
+export class UploadPacer {
+    constructor(rateLimit, now = Date.now) {
+        _UploadPacer_instances.add(this);
+        _UploadPacer_requests.set(this, void 0);
+        _UploadPacer_files.set(this, void 0);
+        _UploadPacer_bytes.set(this, void 0);
+        _UploadPacer_now.set(this, void 0);
+        const resolvedRateLimit = resolveRateLimit(rateLimit);
+        const windowMs = resolvedRateLimit?.windowMs ?? 0;
+        __classPrivateFieldSet(this, _UploadPacer_requests, { limit: resolvedRateLimit?.maxRequestsPerWindow ?? 0, windowMs, next: 0 }, "f");
+        __classPrivateFieldSet(this, _UploadPacer_files, { limit: resolvedRateLimit?.maxFilesPerWindow ?? 0, windowMs, next: 0 }, "f");
+        __classPrivateFieldSet(this, _UploadPacer_bytes, { limit: resolvedRateLimit?.maxBytesPerWindow ?? 0, windowMs, next: 0 }, "f");
+        __classPrivateFieldSet(this, _UploadPacer_now, now, "f");
+    }
+    async wait(cost, signal) {
+        const waitMs = __classPrivateFieldGet(this, _UploadPacer_instances, "m", _UploadPacer_reserve).call(this, __classPrivateFieldGet(this, _UploadPacer_now, "f").call(this), cost);
+        if (waitMs <= 0) {
+            return;
+        }
+        await delay(waitMs, undefined, signal ? { signal } : undefined);
+    }
+}
+_UploadPacer_requests = new WeakMap(), _UploadPacer_files = new WeakMap(), _UploadPacer_bytes = new WeakMap(), _UploadPacer_now = new WeakMap(), _UploadPacer_instances = new WeakSet(), _UploadPacer_reserve = function _UploadPacer_reserve(now, cost) {
+    let start = now;
+    for (const budget of [__classPrivateFieldGet(this, _UploadPacer_requests, "f"), __classPrivateFieldGet(this, _UploadPacer_files, "f"), __classPrivateFieldGet(this, _UploadPacer_bytes, "f")]) {
+        if (isBudgetEnabled(budget) && budget.next > start) {
+            start = budget.next;
+        }
+    }
+    __classPrivateFieldGet(this, _UploadPacer_instances, "m", _UploadPacer_reserveAt).call(this, __classPrivateFieldGet(this, _UploadPacer_requests, "f"), start, cost.requests ?? 0);
+    __classPrivateFieldGet(this, _UploadPacer_instances, "m", _UploadPacer_reserveAt).call(this, __classPrivateFieldGet(this, _UploadPacer_files, "f"), start, cost.files ?? 0);
+    __classPrivateFieldGet(this, _UploadPacer_instances, "m", _UploadPacer_reserveAt).call(this, __classPrivateFieldGet(this, _UploadPacer_bytes, "f"), start, cost.bytes ?? 0);
+    return start > now ? start - now : 0;
+}, _UploadPacer_reserveAt = function _UploadPacer_reserveAt(budget, start, cost) {
+    if (!isBudgetEnabled(budget) || cost <= 0) {
+        return;
+    }
+    budget.next = start + scaledWindowCost(budget.windowMs, cost, budget.limit);
+};