@stanterprise/playwright-reporter 0.0.14 → 0.0.16

package/dist/handlers/onTestEndHandler.js

@@ -37,11 +37,19 @@ function handleOnTestEndEvent(test, result, runId, client, options) {
             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.js

@@ -17,6 +17,7 @@ function handleOnTestFailEvent(test, result, runId, grpcClient, options) {
         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/reporter.js

@@ -135,7 +135,9 @@ class StanterpriseReporter {
         console.error(`Stanterprise Reporter: Standard error output - ${chunk.toString()}`);
     }
     onStdOut(chunk, test, result) {
-        // console.log(`Stanterprise Reporter: Standard output - ${chunk.toString()}`);
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Standard output - ${chunk.toString()}`);
+        }
     }
 }
 exports.default = StanterpriseReporter;

package/dist/utils/attachmentProcessor.d.ts

@@ -7,7 +7,7 @@ declare const Attachment: typeof common.v1.common.Attachment;
 /**
  * Process Playwright test attachments into protobuf Attachment objects
  * @param result Test result containing attachments
- * @param maxAttachmentSize Maximum size for attachment content (default 10MB)
+ * @param maxAttachmentSize Maximum size for attachment content (default 1MB, reduced from 10MB)
  */
 export declare function processAttachments(result: TestResult, maxAttachmentSize?: number): InstanceType<typeof Attachment>[];
 /**

package/dist/utils/attachmentProcessor.js

@@ -11,14 +11,16 @@ const BYTES_PER_MB = 1048576;
 /**
  * Process Playwright test attachments into protobuf Attachment objects
  * @param result Test result containing attachments
- * @param maxAttachmentSize Maximum size for attachment content (default 10MB)
+ * @param maxAttachmentSize Maximum size for attachment content (default 1MB, reduced from 10MB)
  */
-function processAttachments(result, maxAttachmentSize = 10485760 // 10MB default
+function processAttachments(result, maxAttachmentSize = 1048576 // 1MB default (reduced from 10MB to prevent large payloads)
 ) {
     const attachments = [];
     if (!result.attachments || result.attachments.length === 0) {
         return attachments;
     }
+    let totalAttachmentSize = 0;
+    const MAX_TOTAL_ATTACHMENT_SIZE = 2097152; // 2MB total limit across all attachments
     for (const attachment of result.attachments) {
         const att = new Attachment({
             name: attachment.name,
@@ -27,19 +29,29 @@ function processAttachments(result, maxAttachmentSize = 10485760 // 10MB default
         // Always prefer path if available to avoid large payloads
         if (attachment.path) {
             att.uri = attachment.path;
+            attachments.push(att);
+            continue;
         }
-        else if (attachment.body) {
-            // Only include body content if it's within size limit
+        if (attachment.body) {
             const bodySize = attachment.body.length;
-            if (bodySize <= maxAttachmentSize) {
-                att.content = attachment.body;
-            }
-            else {
-                // Skip large attachments without path - log warning
+            // Check individual attachment size
+            if (bodySize > maxAttachmentSize) {
                 console.warn(`Attachment "${attachment.name}" (${(bodySize / BYTES_PER_MB).toFixed(2)}MB) exceeds max size ` +
                     `(${(maxAttachmentSize / BYTES_PER_MB).toFixed(2)}MB) and has no path. Skipping content.`);
                 // Still add the attachment metadata without content
+                attachments.push(att);
+                continue;
+            }
+            // Check total accumulated size
+            if (totalAttachmentSize + bodySize > MAX_TOTAL_ATTACHMENT_SIZE) {
+                console.warn(`Attachment "${attachment.name}" (${(bodySize / BYTES_PER_MB).toFixed(2)}MB) would exceed total attachment size limit ` +
+                    `(${(MAX_TOTAL_ATTACHMENT_SIZE / BYTES_PER_MB).toFixed(2)}MB). Skipping content.`);
+                attachments.push(att);
+                continue;
             }
+            // Include content if within limits
+            att.content = attachment.body;
+            totalAttachmentSize += bodySize;
         }
         attachments.push(att);
     }

package/dist/utils/metadataHelpers.js

@@ -4,6 +4,28 @@ exports.buildAnnotationsMetadata = buildAnnotationsMetadata;
 exports.buildTestMetadata = buildTestMetadata;
 exports.buildStepMetadata = buildStepMetadata;
 exports.toMetadataMap = toMetadataMap;
+/**
+ * Maximum length for a single metadata value (100KB)
+ * Large values are often accidentally embedded test data or debug output
+ */
+const MAX_METADATA_VALUE_LENGTH = 102400;
+/**
+ * Maximum total metadata size across all values (1MB)
+ */
+const MAX_TOTAL_METADATA_SIZE = 1048576;
+/**
+ * Truncate a string to a maximum length with ellipsis indicator
+ * @param value String value to truncate
+ * @param maxLength Maximum length (default 100KB)
+ * @returns Truncated string with warning suffix if truncated
+ */
+function truncateValue(value, maxLength = MAX_METADATA_VALUE_LENGTH) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    const truncated = value.substring(0, maxLength - 100);
+    return `${truncated}... [TRUNCATED: original length ${value.length} bytes, showing first ${maxLength - 100} bytes]`;
+}
 /**
  * Build metadata from annotations array
  * @param annotations Array of annotations with type and optional description
@@ -12,12 +34,25 @@ exports.toMetadataMap = toMetadataMap;
  */
 function buildAnnotationsMetadata(annotations, prefix = "annotation") {
     const metadata = {};
-    annotations.forEach((annotation, index) => {
-        metadata[`${prefix}_${index}_type`] = annotation.type;
+    let totalSize = 0;
+    for (let index = 0; index < annotations.length; index++) {
+        const annotation = annotations[index];
+        const typeKey = `${prefix}_${index}_type`;
+        const typeValue = annotation.type;
+        metadata[typeKey] = typeValue;
+        totalSize += typeValue.length;
         if (annotation.description) {
-            metadata[`${prefix}_${index}_description`] = annotation.description;
+            const descKey = `${prefix}_${index}_description`;
+            const descValue = truncateValue(annotation.description);
+            // Skip if adding this would exceed total metadata size
+            if (totalSize + descValue.length > MAX_TOTAL_METADATA_SIZE) {
+                console.warn(`Skipping annotation description for ${typeKey}: would exceed total metadata size limit (${MAX_TOTAL_METADATA_SIZE} bytes)`);
+                continue;
+            }
+            metadata[descKey] = descValue;
+            totalSize += descValue.length;
         }
-    });
+    }
     return metadata;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stanterprise/playwright-reporter",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Custom Playwright test reporter that sends test results to Stanterprise via gRPC",
   "homepage": "https://github.com/stanterprise/stanterprise-playwright-reporter#readme",
   "bugs": {
@@ -53,6 +53,6 @@
     "@grpc/grpc-js": "^1.14.1",
     "@protobuf-ts/grpc-transport": "^2.11.1",
     "@protobuf-ts/grpcweb-transport": "^2.11.1",
-    "@stanterprise/protobuf": "^0.0.20"
+    "@stanterprise/protobuf": "^0.0.21"
   }
 }