@stanterprise/playwright-reporter 0.0.0-debug-flag-2

package/dist/handlers/onBeginHandler.js

@@ -0,0 +1,96 @@
+"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, client, options) {
+    // 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,
+        name: name,
+        test_suites: mapSuites(suite, runId),
+        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).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) {
+    let allSuites = getAllSuites(suite);
+    return allSuites.map((currentSuite) => mapSingleSuite(currentSuite, runId));
+}
+function getAllSuites(suite) {
+    let suites = [];
+    suites.push(suite);
+    suite.suites.forEach((childSuite) => {
+        suites = suites.concat(getAllSuites(childSuite));
+    });
+    return suites;
+}
+function mapSingleSuite(suite, runId) {
+    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,
+        })),
+        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,4 @@
+import { FullResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnEndEvent(result: FullResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onEndHandler.js

@@ -0,0 +1,51 @@
+"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, client, options) {
+    // 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),
+    });
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportRunEnd", request, options.grpcTimeout).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,4 @@
+import { TestError } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnErrorEvent(error: TestError, runId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onErrorHandler.js

@@ -0,0 +1,15 @@
+"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, grpcClient, options) {
+    const request = new events_1.StdErrorEventRequest({
+        run_id: runId,
+        message: error.message,
+        timestamp: (0, timeHelpers_1.createTimestampFromMs)(Date.now()),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportStdError", request, options.grpcTimeout).catch((e) => console.error("Failed to report standard error", e));
+}

package/dist/handlers/onStepBeginHandler.d.ts

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

package/dist/handlers/onStepBeginHandler.js

@@ -0,0 +1,38 @@
+"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, client, options) {
+    // 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,
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepBegin", request, options.grpcTimeout).catch((e) => console.error("Failed to report step begin", e));
+}

package/dist/handlers/onStepEndHandler.d.ts

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

package/dist/handlers/onStepEndHandler.js

@@ -0,0 +1,59 @@
+"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, client, options) {
+    // Map step error to status
+    const stepStatus = (0, utils_1.mapStepStatus)(!!step.error);
+    // 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,
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepEnd", request, options.grpcTimeout).catch((e) => console.error("Failed to report step end", e));
+}

package/dist/handlers/onTestBeginHandler.d.ts

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

package/dist/handlers/onTestBeginHandler.js

@@ -0,0 +1,32 @@
+"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, client, options) {
+    // 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,
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests; log errors once.
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestBegin", request, options.grpcTimeout).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,4 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnTestEndEvent(test: TestCase, result: TestResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onTestEndHandler.js

@@ -0,0 +1,57 @@
+"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, client, options) {
+    // 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,
+        }),
+    });
+    // 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).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,4 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnTestFailEvent(test: TestCase, result: TestResult, runId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onTestFailHandler.js

@@ -0,0 +1,24 @@
+"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, grpcClient, options) {
+    // 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,
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportTestFailure", request, options.grpcTimeout).catch((e) => console.error("Failed to report test failure", e));
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./reporter";
+export { default as StanterpriseReporter } from "./reporter";
+export type { StanterpriseReporterOptions, TestExecutionContext, StepExecutionContext } from "./types";

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StanterpriseReporter = exports.default = void 0;
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(reporter_1).default; } });
+var reporter_2 = require("./reporter");
+Object.defineProperty(exports, "StanterpriseReporter", { enumerable: true, get: function () { return __importDefault(reporter_2).default; } });

package/dist/reporter.d.ts

@@ -0,0 +1,22 @@
+import type { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult, TestStep, TestError } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "./types";
+export default class StanterpriseReporter implements Reporter {
+    private grpcClient;
+    private options;
+    private runId;
+    private runStartTime;
+    constructor(options?: StanterpriseReporterOptions);
+    onBegin(config: FullConfig, suite: Suite): void;
+    onExit(): Promise<void>;
+    onEnd(result: FullResult): Promise<{
+        status?: FullResult["status"];
+    } | undefined | void> | void;
+    onTestBegin(test: TestCase, result: TestResult): void;
+    onStepBegin(test: TestCase, result: TestResult, step: TestStep): Promise<void>;
+    onStepEnd(test: TestCase, result: TestResult, step: TestStep): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onTestFail(test: TestCase, result: TestResult): void;
+    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;
+}

package/dist/reporter.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const optionsMapper_1 = __importDefault(require("./utils/optionsMapper"));
+const debugLogger_1 = require("./utils/debugLogger");
+const grpcClient_1 = __importDefault(require("./client/grpcClient"));
+const handlers_1 = require("./handlers");
+class StanterpriseReporter {
+    constructor(options = {}) {
+        // Generic gRPC client (we call unary methods by path directly).
+        this.grpcClient = null;
+        this.options = {};
+        // Generate a unique run ID for this test run
+        this.runId = "";
+        this.runStartTime = new Date();
+        this.options = (0, optionsMapper_1.default)(options);
+        if (this.options.verbose) {
+            console.log("Stanterprise Reporter: Initialized with options:", {
+                grpcAddress: this.options.grpcAddress,
+                grpcEnabled: this.options.grpcEnabled,
+                grpcTimeout: this.options.grpcTimeout,
+                verbose: this.options.verbose,
+            });
+        }
+        // Generate a UUID for runId
+        this.runId = process.env.STANTERPRISE_RUN_ID || (0, crypto_1.randomUUID)();
+        // Initialize debug file (creates/truncates it) when debug mode is enabled
+        (0, debugLogger_1.initDebugFile)(this.options);
+    }
+    onBegin(config, suite) {
+        // Lazily create the client if enabled.
+        if (this.options.grpcEnabled) {
+            this.grpcClient = (0, grpcClient_1.default)(this.options);
+            if (!this.grpcClient) {
+                console.warn(`Stanterprise Reporter: Failed to create gRPC client. Disabling gRPC reporting.`);
+                this.options.grpcEnabled = false;
+            }
+        }
+        else {
+            if (this.options.verbose) {
+                console.log("Stanterprise Reporter: gRPC disabled via STANTERPRISE_GRPC_ENABLED=false");
+            }
+        }
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Test run started with ID: ${this.runId}`);
+            console.log(`Number of tests: ${suite.allTests().length}`);
+            console.log(`Run started at: ${this.runStartTime.toISOString()}`);
+            if (config.shard) {
+                console.log(`Shard: ${config.shard.current} of ${config.shard.total}`);
+            }
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnBeginEvent)(config, suite, process.env.STANTERPRISE_TEST_RUN_NAME || "Playwright Test Run", this.runId, this.grpcClient, this.options);
+        }
+    }
+    async onExit() {
+        console.log(`Stanterprise Reporter: Test run completed - Run ID: ${this.runId}`);
+        // Cleanup gRPC client
+        try {
+            this.grpcClient?.close();
+        }
+        catch (e) {
+            console.error("Stanterprise Reporter: Error during gRPC client cleanup in onExit:", e);
+        }
+    }
+    onEnd(result) {
+        const runDuration = Date.now() - this.runStartTime.getTime();
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Test run ended - Run ID: ${this.runId}`);
+            console.log(`Final result: ${result.status}`);
+            console.log(`Run duration: ${runDuration}ms (Playwright duration: ${result.duration}ms)`);
+            console.log(`Run start time: ${this.runStartTime.toISOString()}`);
+            console.log(`Playwright start time: ${result.startTime.toISOString()}`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnEndEvent)(result, this.runId, this.grpcClient, this.options);
+        }
+        return Promise.resolve();
+    }
+    onTestBegin(test, result) {
+        // Create unique test execution ID combining run ID and test ID
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Test started - ${test.title}`);
+            console.log(`  Run ID: ${this.runId}`);
+            console.log(`  Test ID: ${test.id}`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnTestBeginEvent)(test, result, this.runId, this.grpcClient, this.options);
+        }
+    }
+    async onStepBegin(test, result, step) {
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Step started - ${step.title}`);
+            console.log(`  Category: ${step.category}`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnStepBeginEvent)(test, result, step, this.runId, this.grpcClient, this.options);
+        }
+    }
+    onStepEnd(test, result, step) {
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Step ended - ${step.title}`);
+            console.log(`  Duration: ${step.duration}ms`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnStepEndEvent)(test, result, step, this.runId, this.grpcClient, this.options);
+        }
+    }
+    onTestEnd(test, result) {
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Test ended - ${test.title}`);
+            console.log(`  Status: ${result.status}`);
+            console.log(`  Duration: ${result.duration}ms`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnTestEndEvent)(test, result, this.runId, this.grpcClient, this.options);
+        }
+    }
+    onTestFail(test, result) {
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Test failed - ${test.title}`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnTestFailEvent)(test, result, this.runId, this.grpcClient, this.options);
+        }
+    }
+    onError(error) {
+        console.error("Stanterprise Reporter: An error occurred during the test run");
+        console.error(`Error: ${error.message}`);
+        if (error.stack) {
+            console.error(`Stack trace: ${error.stack}`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnErrorEvent)(error, this.runId, this.grpcClient, this.options);
+        }
+    }
+    onStdErr(chunk, test, result) {
+        console.error(`Stanterprise Reporter: Standard error output - ${chunk.toString()}`);
+    }
+    onStdOut(chunk, test, result) {
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Standard output - ${chunk.toString()}`);
+        }
+    }
+}
+exports.default = StanterpriseReporter;