@stanterprise/playwright-reporter 0.0.14 → 0.0.15

package/dist/handlers/onTestEndHandler.js

@@ -42,6 +42,12 @@ function handleOnTestEndEvent(test, result, runId, client, options) {
     // 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/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.15",
   "description": "Custom Playwright test reporter that sends test results to Stanterprise via gRPC",
   "homepage": "https://github.com/stanterprise/stanterprise-playwright-reporter#readme",
   "bugs": {