@stanterprise/playwright-reporter 1.0.0 → 1.1.0

package/dist/client/messageQueue.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueue = void 0;
+/**
+ * A sequential async message queue that processes enqueued tasks one at a time,
+ * guaranteeing that each task completes before the next one begins.
+ *
+ * This ensures that gRPC messages are delivered to the server in the exact order
+ * they were enqueued, regardless of how quickly each individual call completes.
+ * It also serializes debug file writes as a side effect, since those are performed
+ * inside each task.
+ */
+class MessageQueue {
+    constructor() {
+        this.tasks = [];
+        this.processing = false;
+        this.drainResolvers = [];
+    }
+    /**
+     * Adds a task to the queue and returns a Promise that resolves (or rejects)
+     * when the task has been executed. If the queue is idle the task starts
+     * immediately; otherwise it waits for all preceding tasks to finish first.
+     */
+    enqueue(fn) {
+        return new Promise((resolve, reject) => {
+            this.tasks.push(async () => {
+                try {
+                    const result = await fn();
+                    resolve(result);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            if (!this.processing) {
+                this.processNext();
+            }
+        });
+    }
+    /**
+     * Returns a Promise that resolves once the queue has been fully drained
+     * (i.e. all currently enqueued tasks have finished). Resolves immediately
+     * if the queue is already empty.
+     */
+    drain() {
+        if (!this.processing && this.tasks.length === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.drainResolvers.push(resolve);
+        });
+    }
+    async processNext() {
+        this.processing = true;
+        while (this.tasks.length > 0) {
+            const task = this.tasks.shift();
+            try {
+                await task();
+            }
+            catch {
+                // Each task's promise already carries the error to its caller.
+                // Errors must not stop the queue from processing subsequent tasks.
+            }
+        }
+        this.processing = false;
+        const resolvers = this.drainResolvers;
+        this.drainResolvers = [];
+        resolvers.forEach((r) => r());
+    }
+}
+exports.MessageQueue = MessageQueue;

package/dist/handlers/index.d.ts

@@ -0,0 +1,9 @@
+import { handleOnBeginEvent } from "./onBeginHandler";
+import { handleOnEndEvent } from "./onEndHandler";
+import { handleOnStepBeginEvent } from "./onStepBeginHandler";
+import { handleOnStepEndEvent } from "./onStepEndHandler";
+import { handleOnTestBeginEvent } from "./onTestBeginHandler";
+import { handleOnTestEndEvent } from "./onTestEndHandler";
+import { handleOnTestFailEvent } from "./onTestFailHandler";
+import { handleOnErrorEvent } from "./onErrorHandler";
+export { handleOnBeginEvent, handleOnEndEvent, handleOnStepBeginEvent, handleOnStepEndEvent, handleOnTestBeginEvent, handleOnTestEndEvent, handleOnTestFailEvent, handleOnErrorEvent, };

package/dist/handlers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnErrorEvent = exports.handleOnTestFailEvent = exports.handleOnTestEndEvent = exports.handleOnTestBeginEvent = exports.handleOnStepEndEvent = exports.handleOnStepBeginEvent = exports.handleOnEndEvent = exports.handleOnBeginEvent = void 0;
+const onBeginHandler_1 = require("./onBeginHandler");
+Object.defineProperty(exports, "handleOnBeginEvent", { enumerable: true, get: function () { return onBeginHandler_1.handleOnBeginEvent; } });
+const onEndHandler_1 = require("./onEndHandler");
+Object.defineProperty(exports, "handleOnEndEvent", { enumerable: true, get: function () { return onEndHandler_1.handleOnEndEvent; } });
+const onStepBeginHandler_1 = require("./onStepBeginHandler");
+Object.defineProperty(exports, "handleOnStepBeginEvent", { enumerable: true, get: function () { return onStepBeginHandler_1.handleOnStepBeginEvent; } });
+const onStepEndHandler_1 = require("./onStepEndHandler");
+Object.defineProperty(exports, "handleOnStepEndEvent", { enumerable: true, get: function () { return onStepEndHandler_1.handleOnStepEndEvent; } });
+const onTestBeginHandler_1 = require("./onTestBeginHandler");
+Object.defineProperty(exports, "handleOnTestBeginEvent", { enumerable: true, get: function () { return onTestBeginHandler_1.handleOnTestBeginEvent; } });
+const onTestEndHandler_1 = require("./onTestEndHandler");
+Object.defineProperty(exports, "handleOnTestEndEvent", { enumerable: true, get: function () { return onTestEndHandler_1.handleOnTestEndEvent; } });
+const onTestFailHandler_1 = require("./onTestFailHandler");
+Object.defineProperty(exports, "handleOnTestFailEvent", { enumerable: true, get: function () { return onTestFailHandler_1.handleOnTestFailEvent; } });
+const onErrorHandler_1 = require("./onErrorHandler");
+Object.defineProperty(exports, "handleOnErrorEvent", { enumerable: true, get: function () { return onErrorHandler_1.handleOnErrorEvent; } });

package/dist/handlers/onBeginHandler.d.ts

@@ -0,0 +1,6 @@
+import { FullConfig } from "@playwright/test";
+import { Suite } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnBeginEvent(config: FullConfig, suite: Suite, name: string, runId: string, executionId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onBeginHandler.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnBeginEvent = handleOnBeginEvent;
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const grpcClient_1 = require("../client/grpcClient");
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const utils_1 = require("../utils");
+const common_1 = require("@stanterprise/protobuf/testsystem/v1/common");
+function handleOnBeginEvent(config, suite, name, runId, executionId, client, options, queue) {
+    // Report root suite and all child suites recursively
+    // Convert all metadata values to strings for protobuf compatibility
+    // Use plain object instead of Map - protobuf expects object literals
+    const metadata = {};
+    Object.entries(config.metadata || {}).forEach(([key, value]) => {
+        metadata[key] = String(value);
+    });
+    const variables = (0, utils_1.getEnvVariables)();
+    // Merge environment variables into metadata
+    variables.forEach((value, key) => {
+        metadata[key] = value;
+    });
+    // Add shard information if present
+    if (config.shard) {
+        metadata["shard.current"] = String(config.shard.current);
+        metadata["shard.total"] = String(config.shard.total);
+    }
+    const request = new events_1.ReportRunStartEventRequest({
+        run_id: runId,
+        execution_id: executionId,
+        name: name,
+        test_suites: mapSuites(suite, runId, executionId),
+        total_tests: suite.allTests().length,
+        metadata: (0, utils_1.toMetadataMap)(metadata),
+    });
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportRunStart", request, options.grpcTimeout, queue).catch((e) => {
+        const details = e instanceof Error ? `${e.message}` : String(e);
+        console.warn(`onBegin. gRPC disabled for the remainder of the run. Address=${options.grpcAddress}. Details: ${details}`);
+    });
+}
+function mapSuites(suite, runId, executionId) {
+    let allSuites = getAllSuites(suite);
+    return allSuites.map((currentSuite) => mapSingleSuite(currentSuite, runId, executionId));
+}
+function getAllSuites(suite) {
+    let suites = [];
+    suites.push(suite);
+    suite.suites.forEach((childSuite) => {
+        suites = suites.concat(getAllSuites(childSuite));
+    });
+    return suites;
+}
+function mapSingleSuite(suite, runId, executionId) {
+    const suiteId = (0, utils_1.generateSuiteId)(suite);
+    const parentSuiteId = suite.parent
+        ? (0, utils_1.generateSuiteId)(suite.parent)
+        : undefined;
+    let type;
+    switch (suite.type) {
+        case "root":
+            type = entities_1.SuiteType.ROOT;
+            break;
+        case "describe":
+            type = entities_1.SuiteType.SUBSUITE;
+            break;
+        case "file":
+            type = entities_1.SuiteType.FILE;
+            break;
+        case "project":
+            type = entities_1.SuiteType.PROJECT;
+            break;
+    }
+    return new entities_1.TestSuiteRun({
+        id: suiteId,
+        name: suite.title,
+        run_id: runId,
+        parent_suite_id: parentSuiteId,
+        status: common_1.TestStatus.NOT_RUN,
+        test_cases: suite.tests.map((test) => new entities_1.TestCaseRun({
+            id: test.id,
+            name: test.title,
+            run_id: runId,
+            test_suite_id: suiteId,
+            tags: test.tags,
+            location: test.location
+                ? `${test.location.file}:${test.location.line}:${test.location.column}`
+                : undefined,
+            status: common_1.TestStatus.NOT_RUN,
+            retry_count: test.retries,
+            retry_index: 0,
+            execution_id: executionId,
+        })),
+        test_case_ids: suite.tests.map((test) => test.id),
+        type: type,
+        location: suite.location
+            ? `${suite.location.file}:${suite.location.line}:${suite.location.column}`
+            : undefined,
+    });
+}

package/dist/handlers/onEndHandler.d.ts

@@ -0,0 +1,5 @@
+import { FullResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnEndEvent(result: FullResult, runId: string, executionId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue, metadata?: Record<string, string>): void;

package/dist/handlers/onEndHandler.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnEndEvent = handleOnEndEvent;
+const grpcClient_1 = require("../client/grpcClient");
+const utils_1 = require("../utils");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const common_1 = require("@stanterprise/protobuf/testsystem/v1/common");
+function mapTestStatus(status) {
+    switch (status) {
+        case "passed":
+            return common_1.TestStatus.PASSED;
+        case "failed":
+            return common_1.TestStatus.FAILED;
+        case "timedout":
+            return common_1.TestStatus.TIMEDOUT;
+        case "interrupted":
+            return common_1.TestStatus.INTERRUPTED;
+        default:
+            return common_1.TestStatus.UNKNOWN;
+    }
+}
+function handleOnEndEvent(result, runId, executionId, client, options, queue, metadata) {
+    // Validate and sanitize inputs to prevent serialization failures
+    const startTimeMs = result.startTime?.getTime();
+    const duration = result.duration;
+    // Ensure valid numeric values (protobuf cannot serialize NaN or undefined)
+    const validStartTimeMs = typeof startTimeMs === "number" && !isNaN(startTimeMs)
+        ? startTimeMs
+        : Date.now();
+    const validDuration = typeof duration === "number" && !isNaN(duration) && duration >= 0
+        ? duration
+        : 0;
+    const request = new events_1.TestRunEndEventRequest({
+        run_id: runId,
+        final_status: mapTestStatus(result.status),
+        start_time: (0, utils_1.createTimestampFromMs)(validStartTimeMs),
+        duration: (0, utils_1.createDuration)(validDuration),
+        metadata: (0, utils_1.toMetadataMap)(metadata || {}),
+        execution_id: executionId,
+    });
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportRunEnd", request, options.grpcTimeout, queue).catch((error) => {
+        if (error instanceof Error) {
+            console.error(`Failed to report end event: ${error.message}`, {
+                stack: error.stack,
+            });
+        }
+        else {
+            console.error("Failed to report end event: Unknown error type", {
+                error,
+            });
+        }
+    });
+}

package/dist/handlers/onErrorHandler.d.ts

@@ -0,0 +1,5 @@
+import { TestError } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnErrorEvent(error: TestError, runId: string, executionId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onErrorHandler.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnErrorEvent = handleOnErrorEvent;
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const timeHelpers_1 = require("../utils/timeHelpers");
+const grpcClient_1 = require("../client/grpcClient");
+function handleOnErrorEvent(error, runId, executionId, grpcClient, options, queue) {
+    const request = new events_1.StdErrorEventRequest({
+        run_id: runId,
+        message: error.message,
+        timestamp: (0, timeHelpers_1.createTimestampFromMs)(Date.now()),
+        execution_id: executionId,
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportStdError", request, options.grpcTimeout, queue).catch((e) => console.error("Failed to report standard error", e));
+}

package/dist/handlers/onStepBeginHandler.d.ts

@@ -0,0 +1,5 @@
+import { TestCase, TestResult, TestStep } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnStepBeginEvent(test: TestCase, result: TestResult, step: TestStep, runId: string, executionId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onStepBeginHandler.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnStepBeginEvent = handleOnStepBeginEvent;
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const utils_1 = require("../utils");
+const grpcClient_1 = require("../client/grpcClient");
+const utils_2 = require("../utils");
+const common_1 = require("@stanterprise/protobuf/testsystem/v1/common");
+function handleOnStepBeginEvent(test, result, step, runId, executionId, client, options, queue) {
+    // Build metadata from step annotations
+    const metadata = (0, utils_1.buildStepMetadata)(step);
+    // Get parent step ID if this step has a parent
+    const stepId = (0, utils_2.generateStepId)(step, test);
+    // Build and send the StepBegin event
+    const request = new events_1.StepBeginEventRequest({
+        step: new entities_1.StepRun({
+            id: stepId,
+            run_id: runId,
+            test_case_id: test.id,
+            title: step.title,
+            status: common_1.TestStatus.RUNNING,
+            type: step.category,
+            start_time: (0, utils_1.createTimestamp)(step.startTime),
+            location: step.location
+                ? `${step.location.file}:${step.location.line}:${step.location.column}`
+                : undefined,
+            metadata: (0, utils_1.toMetadataMap)(metadata),
+            parent_step_id: step.parent
+                ? (0, utils_2.generateStepId)(step.parent, test)
+                : undefined,
+            worker_index: result.workerIndex.toString(),
+            retry_index: result.retry,
+            execution_id: executionId,
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepBegin", request, options.grpcTimeout, queue).catch((e) => console.error("Failed to report step begin", e));
+}

package/dist/handlers/onStepEndHandler.d.ts

@@ -0,0 +1,5 @@
+import { TestCase, TestResult, TestStep } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnStepEndEvent(test: TestCase, result: TestResult, step: TestStep, runId: string, executionId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onStepEndHandler.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnStepEndEvent = handleOnStepEndEvent;
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const utils_1 = require("../utils");
+const grpcClient_1 = require("../client/grpcClient");
+const utils_2 = require("../utils");
+function handleOnStepEndEvent(test, result, step, runId, executionId, client, options, queue) {
+    // Map step error to status
+    const stepStatus = (0, utils_1.mapStepStatus)(!!step.error);
+    const attachments = (0, utils_1.processAttachments)(result, options.maxAttachmentSize || 10485760);
+    // Build metadata from step annotations
+    const metadata = (0, utils_1.buildStepMetadata)(step);
+    const stepId = (0, utils_2.generateStepId)(step, test);
+    // Extract comprehensive error details if present
+    const errorMessage = step.error?.message || "";
+    const errorStack = step.error?.stack || "";
+    const errorValue = step.error?.value || "";
+    const errorSnippet = step.error?.snippet || "";
+    const errorLocation = step.error?.location
+        ? `${step.error.location.file}:${step.error.location.line}:${step.error.location.column}`
+        : "";
+    // Combine all error information into metadata for comprehensive error tracking
+    const errorMetadata = {};
+    if (errorStack)
+        errorMetadata.error_stack = (0, utils_1.truncateValue)(errorStack);
+    if (errorValue)
+        errorMetadata.error_value = (0, utils_1.truncateValue)(errorValue);
+    if (errorSnippet)
+        errorMetadata.error_snippet = (0, utils_1.truncateValue)(errorSnippet);
+    if (errorLocation)
+        errorMetadata.error_location = (0, utils_1.truncateValue)(errorLocation);
+    // Build and send the StepEnd event
+    const request = new events_1.StepEndEventRequest({
+        step: new entities_1.StepRun({
+            id: stepId,
+            run_id: runId,
+            test_case_id: test.id,
+            title: step.title,
+            type: step.category,
+            start_time: (0, utils_1.createTimestamp)(step.startTime),
+            duration: (0, utils_1.createDuration)(step.duration),
+            status: stepStatus,
+            error: errorMessage,
+            errors: errorMessage ? [errorMessage] : [],
+            location: step.location
+                ? `${step.location.file}:${step.location.line}:${step.location.column}`
+                : "",
+            metadata: (0, utils_1.toMetadataMap)({ ...metadata, ...errorMetadata }),
+            parent_step_id: step.parent
+                ? (0, utils_2.generateStepId)(step.parent, test)
+                : undefined,
+            worker_index: result.workerIndex.toString(),
+            retry_index: result.retry,
+            attachments: attachments,
+            execution_id: executionId,
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepEnd", request, options.grpcTimeout, queue).catch((e) => console.error("Failed to report step end", e));
+}

package/dist/handlers/onTestBeginHandler.d.ts

@@ -0,0 +1,5 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnTestBeginEvent(test: TestCase, result: TestResult, runId: string, executionId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onTestBeginHandler.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnTestBeginEvent = handleOnTestBeginEvent;
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const utils_1 = require("../utils");
+const grpcClient_1 = require("../client/grpcClient");
+const common_1 = require("@stanterprise/protobuf/testsystem/v1/common");
+function handleOnTestBeginEvent(test, result, runId, executionId, client, options, queue) {
+    // Build and send the TestBegin event via generic unary call.
+    const request = new events_1.TestBeginEventRequest({
+        test_case: new entities_1.TestCaseRun({
+            id: test.id,
+            name: test.title,
+            run_id: runId,
+            retry_index: result.retry,
+            retry_count: test.retries,
+            location: test.location
+                ? `${test.location.file}:${test.location.line}:${test.location.column}`
+                : undefined,
+            status: common_1.TestStatus.RUNNING,
+            test_suite_id: (0, utils_1.generateSuiteId)(test.parent),
+            start_time: (0, utils_1.createTimestamp)(result.startTime),
+            tags: test.tags,
+            execution_id: executionId,
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests; log errors once.
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestBegin", request, options.grpcTimeout, queue).catch((e) => {
+        const details = e instanceof Error ? `${e.message}` : String(e);
+        console.warn(`Failed to report test begin. Details: ${details}`);
+    });
+}

package/dist/handlers/onTestEndHandler.d.ts

@@ -0,0 +1,5 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnTestEndEvent(test: TestCase, result: TestResult, runId: string, executionId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onTestEndHandler.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnTestEndEvent = handleOnTestEndEvent;
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const utils_1 = require("../utils");
+const grpcClient_1 = require("../client/grpcClient");
+const utils_2 = require("../utils");
+/**
+ * Constant for converting bytes to megabytes
+ */
+const BYTES_PER_MB = 1048576;
+function handleOnTestEndEvent(test, result, runId, executionId, client, options, queue) {
+    // Map Playwright test status to protobuf TestStatus
+    const testStatus = (0, utils_1.mapTestStatus)(result.status);
+    // Process attachments (screenshots, videos, etc.)
+    const attachments = (0, utils_1.processAttachments)(result, options.maxAttachmentSize || 10485760);
+    // Extract error information if the test failed
+    const { errorMessage, stackTrace, errors } = (0, utils_1.extractErrorInfo)(result);
+    // Get test suite run ID from parent suite if available, ensuring suite is reported
+    const suiteId = (0, utils_2.generateSuiteId)(test.parent);
+    // Build metadata from test annotations and result metadata
+    const metadata = (0, utils_1.buildTestMetadata)(test, result);
+    // Build and send the TestEnd event
+    const request = new events_1.TestEndEventRequest({
+        test_case: new entities_1.TestCaseRun({
+            id: test.id,
+            name: test.title,
+            run_id: runId,
+            test_suite_id: suiteId,
+            status: testStatus,
+            start_time: (0, utils_1.createTimestamp)(result.startTime),
+            duration: (0, utils_1.createDuration)(result.duration),
+            attachments: attachments,
+            error_message: errorMessage,
+            stack_trace: stackTrace,
+            errors: errors,
+            metadata: (0, utils_1.toMetadataMap)(metadata),
+            tags: test.tags,
+            retry_index: result.retry,
+            retry_count: test.retries,
+            execution_id: executionId,
+        }),
+    });
+    // Serialize once to capture payload size for potential error logging
+    const serializedPayload = request.serializeBinary();
+    const payloadSize = serializedPayload.length;
+    // Warn if payload is unusually large (>1MB)
+    if (payloadSize > 1048576) {
+        console.warn(`Large payload detected for test "${test.title}": ${(payloadSize / BYTES_PER_MB).toFixed(2)}MB. ` +
+            `Attachments: ${attachments.length}, Metadata keys: ${Object.keys(metadata).length}, ` +
+            `Error length: ${errorMessage.length + stackTrace.length} bytes`);
+    }
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestEnd", request, options.grpcTimeout, queue).catch((e) => {
+        console.error(`Failed to report test end for "${test.title}" (payload size: ${(payloadSize / BYTES_PER_MB).toFixed(2)}MB)`, e);
+    });
+}

package/dist/handlers/onTestFailHandler.d.ts

@@ -0,0 +1,5 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnTestFailEvent(test: TestCase, result: TestResult, runId: string, executionId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onTestFailHandler.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnTestFailEvent = handleOnTestFailEvent;
+const utils_1 = require("../utils");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const grpcClient_1 = require("../client/grpcClient");
+function handleOnTestFailEvent(test, result, runId, executionId, grpcClient, options, queue) {
+    // Extract failure details
+    const { errorMessage: failureMessage, stackTrace } = (0, utils_1.extractErrorInfo)(result);
+    // Process attachments for failed tests
+    const attachments = (0, utils_1.processAttachments)(result);
+    // Build and send the TestFailure event
+    const request = new events_1.TestFailureEventRequest({
+        test_id: test.id,
+        run_id: runId,
+        failure_message: failureMessage,
+        stack_trace: stackTrace,
+        timestamp: (0, utils_1.createTimestampFromMs)(Date.now()),
+        attachments: attachments,
+        retry_index: result.retry,
+        execution_id: executionId,
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportTestFailure", request, options.grpcTimeout, queue).catch((e) => console.error("Failed to report test failure", e));
+}

package/dist/reporter.d.ts

@@ -2,20 +2,15 @@ import type { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult, Tes
 import { StanterpriseReporterOptions } from "./types";
 export default class StanterpriseReporter implements Reporter {
     private grpcClient;
-    private grpcAddress;
-    private grpcEnabled;
-    private grpcTimeout;
-    private grpcFirstErrorLogged;
-    private verbose;
+    private options;
     private runId;
+    private executionId;
     private runStartTime;
-    private rootSuite;
-    private reportedSuites;
+    private messageQueue;
+    private metadata;
     constructor(options?: StanterpriseReporterOptions);
     onBegin(config: FullConfig, suite: Suite): void;
     onExit(): Promise<void>;
-    getRunId(): string;
-    getRunStartTime(): Date;
     onEnd(result: FullResult): Promise<{
         status?: FullResult["status"];
     } | undefined | void> | void;
@@ -27,10 +22,4 @@ export default class StanterpriseReporter implements Reporter {
     onError(error: TestError): void;
     onStdErr(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
     onStdOut(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
-    private getSuiteId;
-    private reportSuiteBegin;
-    private reportSuiteEnd;
-    private mapSuiteStatus;
-    private logGrpcErrorOnce;
-    private reportUnary;
 }