@stanterprise/playwright-reporter 0.0.18 → 0.0.19

package/README.md

@@ -92,6 +92,46 @@ npx playwright test
 | `grpcMaxMessageSize` | number  | `104857600`       | Max message size in bytes (100MB default)           |
 | `maxAttachmentSize`  | number  | `10485760`        | Max attachment content size in bytes (10MB default) |
 | `verbose`            | boolean | `false`           | Enable verbose logging                              |
+| `grpcMaxRetries`     | number  | `3`               | Maximum number of retry attempts for failed gRPC calls  |
+| `grpcRetryDelay`     | number  | `100`             | Initial delay for retries in ms (uses exponential backoff) |
+
+### Retry Configuration
+
+The reporter automatically retries failed gRPC calls for transient errors using exponential backoff:
+
+- **Retryable errors**: `UNAVAILABLE`, `DEADLINE_EXCEEDED`, `INTERNAL`, `UNKNOWN`
+- **Non-retryable errors**: `INVALID_ARGUMENT`, `NOT_FOUND`, `PERMISSION_DENIED`, `UNAUTHENTICATED`, `ALREADY_EXISTS`
+
+**Exponential backoff formula**: `grpcRetryDelay * (2 ^ attemptNumber)`
+
+Example with default settings (`grpcRetryDelay: 100`, `grpcMaxRetries: 3`):
+- Initial attempt: Immediate
+- Retry 1: Wait 100ms (100 * 2^0)
+- Retry 2: Wait 200ms (100 * 2^1)
+- Retry 3: Wait 400ms (100 * 2^2)
+
+```typescript
+export default defineConfig({
+  reporter: [
+    [
+      "stanterprise-playwright-reporter",
+      {
+        grpcMaxRetries: 5,        // Try up to 5 times
+        grpcRetryDelay: 200,      // Start with 200ms delay
+        verbose: true,            // Log retry attempts
+      },
+    ],
+  ],
+});
+```
+
+To disable retries:
+
+```typescript
+{
+  grpcMaxRetries: 0  // No retries, fail fast
+}
+```
 
 ## Sharding Support
 

package/dist/client/grpcClient.d.ts

@@ -1,6 +1,9 @@
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
 export default function getClient(options: StanterpriseReporterOptions): grpc.Client | null;
+/**
+ * Helper: generic unary call using raw method path with retry support
+ */
 export declare function reportUnary(options: StanterpriseReporterOptions, grpcClient: grpc.Client, path: string, message: {
     serialize?: (w?: any) => Uint8Array;
     serializeBinary?: () => Uint8Array;

package/dist/client/grpcClient.js

@@ -49,11 +49,28 @@ function getClient(options) {
     }
     return null;
 }
-// Helper: generic unary call using raw method path
-async function reportUnary(options, grpcClient, path, message, deadlineMs = 1000) {
-    if (!options.grpcEnabled || !grpcClient) {
-        return Buffer.alloc(0);
-    }
+/**
+ * Determines if a gRPC error code represents a transient failure worth retrying
+ */
+function shouldAttemptRetryForCode(errorCode) {
+    const transientCodes = new Set([
+        grpc.status.UNAVAILABLE,
+        grpc.status.DEADLINE_EXCEEDED,
+        grpc.status.INTERNAL,
+        grpc.status.UNKNOWN,
+    ]);
+    return transientCodes.has(errorCode);
+}
+/**
+ * Calculates wait time using power-of-two exponential backoff
+ */
+function calculateWaitDuration(baseDelayMs, attemptsSoFar) {
+    return baseDelayMs * Math.pow(2, attemptsSoFar);
+}
+/**
+ * Performs a single gRPC unary request attempt
+ */
+function executeSingleAttempt(grpcClient, path, message, deadlineMs) {
     const reqSerialize = (arg) => {
         const m = arg;
         const bytes = m?.serializeBinary
@@ -81,3 +98,59 @@ async function reportUnary(options, grpcClient, path, message, deadlineMs = 1000
         }
     });
 }
+/**
+ * Pauses execution for specified milliseconds with unref'd timer to avoid blocking shutdown
+ */
+function pauseExecution(durationMs) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, durationMs);
+        // Unref the timer so it doesn't keep the process alive
+        timer.unref();
+    });
+}
+/**
+ * Attempts gRPC call with exponential backoff retry logic using iterative approach
+ */
+async function attemptWithRetries(options, grpcClient, path, message, deadlineMs, maxRetries) {
+    let attemptNumber = 0;
+    let lastError = null;
+    // Try initial attempt + retries
+    for (let retriesRemaining = maxRetries; retriesRemaining >= 0; retriesRemaining--) {
+        try {
+            return await executeSingleAttempt(grpcClient, path, message, deadlineMs);
+        }
+        catch (err) {
+            lastError = err;
+            const grpcErr = err;
+            const statusCode = grpcErr?.code ?? grpc.status.UNKNOWN;
+            // Check if we should retry this error
+            const isRetryable = shouldAttemptRetryForCode(statusCode);
+            const hasRetriesLeft = retriesRemaining > 0;
+            if (!isRetryable || !hasRetriesLeft) {
+                throw err;
+            }
+            // Log retry attempt if verbose
+            if (options.verbose) {
+                console.log(`gRPC call failed (code: ${statusCode}), retrying... ` +
+                    `(attempt ${attemptNumber + 1}, ${retriesRemaining} retries left)`);
+            }
+            // Calculate and wait for backoff duration
+            const baseDelay = options.grpcRetryDelay ?? 100;
+            const waitTime = calculateWaitDuration(baseDelay, attemptNumber);
+            await pauseExecution(waitTime);
+            attemptNumber++;
+        }
+    }
+    // This should never be reached due to the throw in the loop, but TypeScript needs it
+    throw lastError || new Error("Retry loop exhausted without result");
+}
+/**
+ * Helper: generic unary call using raw method path with retry support
+ */
+async function reportUnary(options, grpcClient, path, message, deadlineMs = 1000) {
+    if (!options.grpcEnabled || !grpcClient) {
+        return Buffer.alloc(0);
+    }
+    const maxRetries = options.grpcMaxRetries ?? 3;
+    return attemptWithRetries(options, grpcClient, path, message, deadlineMs, maxRetries);
+}

package/dist/types.d.ts

@@ -36,6 +36,17 @@ export interface StanterpriseReporterOptions {
      * @default false
      */
     verbose?: boolean;
+    /**
+     * Maximum number of retry attempts for failed gRPC calls
+     * @default 3
+     */
+    grpcMaxRetries?: number;
+    /**
+     * Initial delay between retry attempts in milliseconds
+     * Actual delay uses exponential backoff: initialDelay * (2 ^ attemptNumber)
+     * @default 100
+     */
+    grpcRetryDelay?: number;
 }
 /**
  * Internal type for managing test execution state

package/dist/utils/optionsMapper.js

@@ -16,6 +16,10 @@ function defineOptions(providedOptions) {
         providedOptions.grpcEnabled ??
             (process.env.STANTERPRISE_GRPC_ENABLED || "true").toLowerCase() !== "false";
     result.grpcTimeout = providedOptions.grpcTimeout || 1000;
+    result.grpcMaxMessageSize = providedOptions.grpcMaxMessageSize || 104857600;
+    result.maxAttachmentSize = providedOptions.maxAttachmentSize || 10485760;
     result.verbose = providedOptions.verbose || false;
+    result.grpcMaxRetries = providedOptions.grpcMaxRetries ?? 3;
+    result.grpcRetryDelay = providedOptions.grpcRetryDelay || 100;
     return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stanterprise/playwright-reporter",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Custom Playwright test reporter that sends test results to Stanterprise via gRPC",
   "homepage": "https://github.com/stanterprise/stanterprise-playwright-reporter#readme",
   "bugs": {