@checkly/playwright-reporter 0.1.8 → 0.1.10

package/dist/index.d.ts

@@ -81,6 +81,13 @@ interface ChecklyReporterOptions {
      * sessionName: ({ directoryName, config }) => `E2E: ${directoryName} (${config.projects.length} projects)`
      */
     sessionName?: SessionNameOption;
+    /**
+     * Enable verbose logging for debugging
+     * Logs detailed information about each phase of report generation
+     * Can also be enabled via CHECKLY_REPORTER_VERBOSE=true environment variable
+     * @default false
+     */
+    verbose?: boolean;
 }
 /**
  * Warning types that can be attached to test results
@@ -99,6 +106,67 @@ interface ChecklyWarning {
      */
     message: string;
 }
+/**
+ * Console message type matching the webapp's CheckRunNavigationTracePage.console type
+ */
+type ConsoleMessageType = 'debug' | 'error' | 'info' | 'log' | 'warning';
+/**
+ * Location of a console message in source code
+ */
+interface ConsoleMessageLocation {
+    url: string;
+    columnNumber: number;
+    lineNumber: number;
+}
+/**
+ * Console message extracted from Playwright trace
+ * Matches the webapp's CheckRunNavigationTracePage.console array item type
+ */
+interface ConsoleMessage {
+    /**
+     * Unique identifier for the console message
+     */
+    id: string;
+    /**
+     * Source location where the console message was triggered
+     */
+    location: ConsoleMessageLocation;
+    /**
+     * The text content of the console message
+     */
+    text: string;
+    /**
+     * Timestamp when the message was logged (milliseconds)
+     */
+    timestamp: number;
+    /**
+     * Type of console message
+     */
+    type: ConsoleMessageType;
+}
+/**
+ * Network request extracted from Playwright trace
+ * Matches the webapp's CheckRunNavigationTraceNetworkEntry type
+ */
+interface NetworkRequest {
+    id: string;
+    url: string;
+    domain: string;
+    method: string;
+    resourceType: string;
+    statusCode: number;
+    statusText: string;
+    start: number;
+    startedAt: number;
+    finishedAt: number;
+    time: number;
+    hasFinished: boolean;
+    hasSucceeded: boolean;
+    requestHeaders: Record<string, string>;
+    responseHeaders: Record<string, string>;
+    transferBytes?: number;
+    resourceBytes?: number;
+}
 /**
  * Checkly-specific extensions added to JSONReportTestResult
  */
@@ -107,6 +175,14 @@ interface ChecklyTestResultExtensions {
      * Warnings about the test result (e.g., missing traces)
      */
     warnings?: ChecklyWarning[];
+    /**
+     * Console messages extracted from the Playwright trace
+     */
+    console?: ConsoleMessage[];
+    /**
+     * Network requests extracted from the Playwright trace
+     */
+    network?: NetworkRequest[];
 }
 /**
  * Extended JSONReportTestResult with Checkly-specific data
@@ -168,6 +244,13 @@ declare class ChecklyReporter implements Reporter {
     private testCounts;
     private stepsMap;
     private warningsMap;
+    private tracePathsMap;
+    private consoleMessagesMap;
+    private networkRequestsMap;
+    /**
+     * Log a message if verbose mode is enabled
+     */
+    private log;
     constructor(options?: ChecklyReporterOptions);
     /**
      * Resolves the session name from options
@@ -176,6 +259,7 @@ declare class ChecklyReporter implements Reporter {
     private resolveSessionName;
     /**
      * Checks if test result has a trace attachment and adds context-aware warning if missing
+     * Also captures trace file path for later console message extraction
      * The warning type depends on the trace configuration and test result state
      */
     private checkTraceAttachment;
@@ -196,10 +280,21 @@ declare class ChecklyReporter implements Reporter {
     onEnd(): Promise<void>;
     private printSummary;
     /**
-     * Injects captured steps and warnings into the JSON report
+     * Extracts console messages and network requests from all captured traces
+     * Called before injecting data into the report
+     */
+    private extractDataFromTraces;
+    /**
+     * Injects captured steps, warnings, console messages, and network requests into the JSON report
      * Traverses the report structure and matches by test ID + retry
      */
     private injectDataIntoReport;
+    /**
+     * Reconstructs config.projects and test.projectId from test data
+     * This is necessary for blob merge scenarios where Playwright's JSON reporter
+     * doesn't populate projects array or projectId fields
+     */
+    private reconstructProjectsFromTests;
     /**
      * Uploads test results to Checkly API
      */
@@ -210,4 +305,4 @@ declare class ChecklyReporter implements Reporter {
     onError(error: TestError): void;
 }
 
-export { ChecklyReporter, type ChecklyReporterOptions, type ChecklyTestResultExtensions, type ChecklyWarning, type ChecklyWarningType, type JSONReport, type JSONReportSpec, type JSONReportSuite, type JSONReportTest, type JSONReportTestResult, ChecklyReporter as default };
+export { ChecklyReporter, type ChecklyReporterOptions, type ChecklyTestResultExtensions, type ChecklyWarning, type ChecklyWarningType, type ConsoleMessage, type ConsoleMessageLocation, type ConsoleMessageType, type JSONReport, type JSONReportSpec, type JSONReportSuite, type JSONReportTest, type JSONReportTestResult, type NetworkRequest, ChecklyReporter as default };

package/dist/index.js

@@ -234,8 +234,261 @@ var AssetCollector = class {
   }
 };
 
-// ../utils/src/zipper.ts
+// ../utils/src/console-adapter.ts
+import { createHash } from "crypto";
+function normalizeType(messageType) {
+  switch (messageType.toLowerCase()) {
+    case "debug":
+      return "debug";
+    case "error":
+      return "error";
+    case "info":
+      return "info";
+    case "warning":
+    case "warn":
+      return "warning";
+    default:
+      return "log";
+  }
+}
+function generateId(time, messageType, text, url) {
+  return createHash("sha256").update(`${time}-${messageType}-${text}-${url}`).digest("hex").substring(0, 16);
+}
+function toConsoleMessage(event) {
+  const url = event.location?.url || "";
+  return {
+    id: generateId(event.time, event.messageType, event.text, url),
+    location: {
+      url,
+      columnNumber: event.location?.columnNumber || 0,
+      lineNumber: event.location?.lineNumber || 0
+    },
+    text: event.text || "",
+    timestamp: event.time,
+    type: normalizeType(event.messageType)
+  };
+}
+
+// ../utils/src/network-adapter.ts
+import { createHash as createHash2 } from "crypto";
+function generateId2(url, method, startedAt) {
+  return createHash2("sha256").update(`${url}-${method}-${startedAt}`).digest("hex").substring(0, 16);
+}
+function extractDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function headersArrayToRecord(headers) {
+  const record = {};
+  for (const { name, value } of headers) {
+    record[name.toLowerCase()] = value;
+  }
+  return record;
+}
+function isSuccessStatus(status) {
+  return status >= 200 && status < 400;
+}
+function determineResourceType(snapshot) {
+  if (snapshot._resourceType) {
+    return snapshot._resourceType;
+  }
+  if (snapshot._apiRequest) {
+    return "fetch";
+  }
+  return "other";
+}
+function toNetworkRequest(event) {
+  const { snapshot } = event;
+  const startedAt = new Date(snapshot.startedDateTime).getTime();
+  const time = Math.round(snapshot.time);
+  const finishedAt = startedAt + time;
+  const statusCode = snapshot.response.status;
+  const url = snapshot.request.url;
+  const method = snapshot.request.method;
+  return {
+    id: generateId2(url, method, startedAt),
+    url,
+    domain: extractDomain(url),
+    method,
+    resourceType: determineResourceType(snapshot),
+    statusCode,
+    statusText: snapshot.response.statusText || "",
+    start: startedAt,
+    startedAt,
+    finishedAt,
+    time,
+    hasFinished: true,
+    hasSucceeded: isSuccessStatus(statusCode),
+    requestHeaders: headersArrayToRecord(snapshot.request.headers || []),
+    responseHeaders: headersArrayToRecord(snapshot.response.headers || []),
+    transferBytes: snapshot.response._transferSize,
+    resourceBytes: snapshot.response.content?.size
+  };
+}
+
+// ../utils/src/trace-reader.ts
 import * as fs2 from "fs";
+
+// ../utils/src/zip-reader.ts
+import { promisify } from "util";
+import * as zlib from "zlib";
+var gunzip2 = promisify(zlib.gunzip);
+var inflateRaw2 = promisify(zlib.inflateRaw);
+function parseZipEntries(zipBuffer) {
+  const EOCD_SIG = 101010256;
+  let eocdOffset = -1;
+  for (let i = zipBuffer.length - 22; i >= 0; i--) {
+    if (zipBuffer.readUInt32LE(i) === EOCD_SIG) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) {
+    return [];
+  }
+  const cdOffset = zipBuffer.readUInt32LE(eocdOffset + 16);
+  const cdEntries = zipBuffer.readUInt16LE(eocdOffset + 10);
+  const entries = [];
+  const CD_SIG = 33639248;
+  let offset = cdOffset;
+  for (let i = 0; i < cdEntries; i++) {
+    if (zipBuffer.readUInt32LE(offset) !== CD_SIG) {
+      break;
+    }
+    const compressionMethod = zipBuffer.readUInt16LE(offset + 10);
+    const compressedSize = zipBuffer.readUInt32LE(offset + 20);
+    const fileNameLength = zipBuffer.readUInt16LE(offset + 28);
+    const extraFieldLength = zipBuffer.readUInt16LE(offset + 30);
+    const commentLength = zipBuffer.readUInt16LE(offset + 32);
+    const localHeaderOffset = zipBuffer.readUInt32LE(offset + 42);
+    const fileName = zipBuffer.subarray(offset + 46, offset + 46 + fileNameLength).toString("utf-8");
+    entries.push({
+      fileName,
+      compressionMethod,
+      compressedSize,
+      localHeaderOffset
+    });
+    offset += 46 + fileNameLength + extraFieldLength + commentLength;
+  }
+  return entries;
+}
+async function readZipEntryContent(zipBuffer, entry) {
+  const LOCAL_SIG = 67324752;
+  if (zipBuffer.readUInt32LE(entry.localHeaderOffset) !== LOCAL_SIG) {
+    return null;
+  }
+  const localFileNameLength = zipBuffer.readUInt16LE(entry.localHeaderOffset + 26);
+  const localExtraLength = zipBuffer.readUInt16LE(entry.localHeaderOffset + 28);
+  const dataOffset = entry.localHeaderOffset + 30 + localFileNameLength + localExtraLength;
+  const compressedData = zipBuffer.subarray(dataOffset, dataOffset + entry.compressedSize);
+  let buffer;
+  if (entry.compressionMethod === 0) {
+    buffer = compressedData;
+  } else if (entry.compressionMethod === 8) {
+    buffer = await inflateRaw2(compressedData);
+  } else {
+    return null;
+  }
+  if (buffer.length >= 2 && buffer[0] === 31 && buffer[1] === 139) {
+    const decompressed = await gunzip2(buffer);
+    return decompressed.toString("utf-8");
+  }
+  return buffer.toString("utf-8");
+}
+
+// ../utils/src/trace-reader.ts
+var TraceReader = class {
+  constructor(tracePath) {
+    this.tracePath = tracePath;
+  }
+  zipBuffer = null;
+  traceEntries = [];
+  async open() {
+    if (!fs2.existsSync(this.tracePath)) {
+      return false;
+    }
+    try {
+      this.zipBuffer = fs2.readFileSync(this.tracePath);
+      const entries = parseZipEntries(this.zipBuffer);
+      this.traceEntries = entries.filter(
+        (e) => (/^\d+-trace\.trace$/.test(e.fileName) || /^\d+-trace\.network$/.test(e.fileName)) && !e.fileName.includes("/")
+      );
+      return this.traceEntries.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Extracts events matching a text filter.
+   *
+   * @param textFilter - Substring to match (e.g., '"type":"console"')
+   * @param adapter - Optional adapter to transform events
+   */
+  async extractEvents(textFilter, adapter) {
+    if (!this.zipBuffer) {
+      throw new Error("TraceReader not opened. Call open() first.");
+    }
+    const results = [];
+    for (const traceEntry of this.traceEntries) {
+      const content = await readZipEntryContent(this.zipBuffer, traceEntry);
+      if (!content) continue;
+      for (const line of content.split("\n")) {
+        if (line.indexOf(textFilter) !== -1) {
+          try {
+            const event = JSON.parse(line);
+            results.push(adapter ? adapter(event) : event);
+          } catch {
+          }
+        }
+      }
+    }
+    if (results.length > 0 && typeof results[0].time === "number") {
+      return results.sort((a, b) => a.time - b.time);
+    }
+    return results;
+  }
+  /**
+   * Extracts all events from the trace.
+   */
+  async extractAllEvents(adapter) {
+    if (!this.zipBuffer) {
+      throw new Error("TraceReader not opened. Call open() first.");
+    }
+    const results = [];
+    for (const traceEntry of this.traceEntries) {
+      const content = await readZipEntryContent(this.zipBuffer, traceEntry);
+      if (!content) continue;
+      for (const line of content.split("\n")) {
+        if (line.trim()) {
+          try {
+            const event = JSON.parse(line);
+            results.push(adapter ? adapter(event) : event);
+          } catch {
+          }
+        }
+      }
+    }
+    if (results.length > 0 && typeof results[0].time === "number") {
+      return results.sort((a, b) => a.time - b.time);
+    }
+    return results;
+  }
+  listFiles() {
+    if (!this.zipBuffer) {
+      return [];
+    }
+    return parseZipEntries(this.zipBuffer).map((e) => e.fileName);
+  }
+  isOpen() {
+    return this.zipBuffer !== null;
+  }
+};
+
+// ../utils/src/zipper.ts
+import * as fs3 from "fs";
 import * as os from "os";
 import * as path2 from "path";
 import { ZipArchive } from "archiver";
@@ -254,7 +507,7 @@ var Zipper = class {
     const entries = [];
     return new Promise((resolve2, reject) => {
       try {
-        const output = fs2.createWriteStream(this.outputPath);
+        const output = fs3.createWriteStream(this.outputPath);
         const archive = new ZipArchive({
           zlib: { level: 0 }
         });
@@ -284,14 +537,14 @@ var Zipper = class {
           reject(err);
         });
         archive.pipe(output);
-        if (!fs2.existsSync(reportPath)) {
+        if (!fs3.existsSync(reportPath)) {
           reject(new Error(`Report file not found: ${reportPath}`));
           return;
         }
         const transformedReportPath = this.transformJsonReport(reportPath);
         archive.file(transformedReportPath, { name: "output/playwright-test-report.json" });
         for (const asset of assets) {
-          if (!fs2.existsSync(asset.sourcePath)) {
+          if (!fs3.existsSync(asset.sourcePath)) {
             console.warn(`[Checkly Reporter] Skipping missing asset: ${asset.sourcePath}`);
             continue;
           }
@@ -310,11 +563,11 @@ var Zipper = class {
    * @returns Path to the transformed JSON report (in temp directory)
    */
   transformJsonReport(reportPath) {
-    const reportContent = fs2.readFileSync(reportPath, "utf-8");
+    const reportContent = fs3.readFileSync(reportPath, "utf-8");
     const report = JSON.parse(reportContent);
     this.transformAttachmentPaths(report);
     const tempReportPath = path2.join(os.tmpdir(), `playwright-test-report-${Date.now()}.json`);
-    fs2.writeFileSync(tempReportPath, JSON.stringify(report, null, 2));
+    fs3.writeFileSync(tempReportPath, JSON.stringify(report, null, 2));
     return tempReportPath;
   }
   /**
@@ -392,8 +645,8 @@ var Zipper = class {
 };
 
 // src/reporter.ts
-import * as fs3 from "fs";
-import { readFileSync as readFileSync3 } from "fs";
+import * as fs4 from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import * as path3 from "path";
 import { dirname, join as join3 } from "path";
 import { fileURLToPath } from "url";
@@ -658,7 +911,7 @@ var TestResults = class {
 // src/reporter.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
-var packageJson = JSON.parse(readFileSync3(join3(__dirname, "..", "package.json"), "utf-8"));
+var packageJson = JSON.parse(readFileSync4(join3(__dirname, "..", "package.json"), "utf-8"));
 var pkgVersion = packageJson.version;
 var pluralRules = new Intl.PluralRules("en-US");
 var projectForms = {
@@ -725,11 +978,30 @@ var ChecklyReporter = class {
   stepsMap = /* @__PURE__ */ new Map();
   // Store warnings per test result, keyed by "testId:retry"
   warningsMap = /* @__PURE__ */ new Map();
+  // Store trace file paths per test result, keyed by "testId:retry"
+  tracePathsMap = /* @__PURE__ */ new Map();
+  // Store console messages per test result, keyed by "testId:retry"
+  consoleMessagesMap = /* @__PURE__ */ new Map();
+  // Store network requests per test result, keyed by "testId:retry"
+  networkRequestsMap = /* @__PURE__ */ new Map();
+  /**
+   * Log a message if verbose mode is enabled
+   */
+  log(message, data) {
+    if (!this.options.verbose) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    if (data) {
+      console.log(`[Checkly Reporter DEBUG ${timestamp}] ${message}`, JSON.stringify(data, null, 2));
+    } else {
+      console.log(`[Checkly Reporter DEBUG ${timestamp}] ${message}`);
+    }
+  }
   constructor(options = {}) {
     const environment = getEnvironment(options);
     const baseUrl = getApiUrl(environment);
     const apiKey = process.env.CHECKLY_API_KEY || options.apiKey;
     const accountId = process.env.CHECKLY_ACCOUNT_ID || options.accountId;
+    const verbose = options.verbose ?? process.env.CHECKLY_REPORTER_VERBOSE === "true";
     this.options = {
       accountId,
       apiKey,
@@ -737,7 +1009,8 @@ var ChecklyReporter = class {
       jsonReportPath: options.jsonReportPath ?? "test-results/playwright-test-report.json",
       testResultsDir: options.testResultsDir ?? "test-results",
       dryRun: options.dryRun ?? false,
-      sessionName: options.sessionName
+      sessionName: options.sessionName,
+      verbose
     };
     this.assetCollector = new AssetCollector(this.options.testResultsDir);
     this.zipper = new Zipper({
@@ -751,6 +1024,20 @@ var ChecklyReporter = class {
       });
       this.testResults = new TestResults(client.getAxiosInstance());
     }
+    if (verbose) {
+      console.log(`[Checkly Reporter DEBUG] Initialized with options:`, {
+        environment,
+        baseUrl,
+        hasApiKey: !!apiKey,
+        hasAccountId: !!accountId,
+        outputPath: this.options.outputPath,
+        jsonReportPath: this.options.jsonReportPath,
+        testResultsDir: this.options.testResultsDir,
+        dryRun: this.options.dryRun,
+        verbose: this.options.verbose,
+        hasTestResults: !!this.testResults
+      });
+    }
   }
   /**
    * Resolves the session name from options
@@ -768,14 +1055,16 @@ var ChecklyReporter = class {
   }
   /**
    * Checks if test result has a trace attachment and adds context-aware warning if missing
+   * Also captures trace file path for later console message extraction
    * The warning type depends on the trace configuration and test result state
    */
   checkTraceAttachment(test, result) {
-    const warningsKey = `${test.id}:${result.retry}`;
-    const hasTrace = result.attachments?.some(
+    const key = `${test.id}:${result.retry}`;
+    const traceAttachment = result.attachments?.find(
       (attachment) => attachment.name === "trace" || attachment.contentType === "application/zip"
     );
-    if (hasTrace) {
+    if (traceAttachment?.path) {
+      this.tracePathsMap.set(key, traceAttachment.path);
       return;
     }
     const traceConfig = test.parent?.project()?.use?.trace;
@@ -841,9 +1130,9 @@ var ChecklyReporter = class {
         warningType = "trace-missing";
         message = `No trace found. Trace mode "${traceMode}" may not be generating traces for this result.`;
     }
-    const warnings = this.warningsMap.get(warningsKey) || [];
+    const warnings = this.warningsMap.get(key) || [];
     warnings.push({ type: warningType, message });
-    this.warningsMap.set(warningsKey, warnings);
+    this.warningsMap.set(key, warnings);
   }
   /**
    * Called once before running tests
@@ -919,9 +1208,16 @@ var ChecklyReporter = class {
    * This is where we create the ZIP archive and upload results
    */
   async onEnd() {
+    this.log("onEnd started", {
+      testCounts: this.testCounts,
+      stepsMapSize: this.stepsMap.size,
+      warningsMapSize: this.warningsMap.size,
+      hasTestSession: !!this.testSession,
+      testSessionId: this.testSession?.testSessionId
+    });
     try {
       const jsonReportPath = this.options.jsonReportPath;
-      if (!fs3.existsSync(jsonReportPath)) {
+      if (!fs4.existsSync(jsonReportPath)) {
         console.error(`[Checkly Reporter] ERROR: JSON report not found at: ${jsonReportPath}`);
         console.error("[Checkly Reporter] Make sure to configure the json reporter before the checkly reporter:");
         console.error(
@@ -929,17 +1225,42 @@ var ChecklyReporter = class {
         );
         return;
       }
-      const reportContent = fs3.readFileSync(jsonReportPath, "utf-8");
+      this.log("Reading JSON report", { path: jsonReportPath });
+      const reportContent = fs4.readFileSync(jsonReportPath, "utf-8");
       const report = JSON.parse(reportContent);
+      this.log("JSON report parsed", {
+        configVersion: report.config?.version,
+        projectsCount: report.config?.projects?.length ?? 0,
+        suitesCount: report.suites?.length ?? 0,
+        rootDir: report.config?.rootDir
+      });
+      await this.extractDataFromTraces();
       this.injectDataIntoReport(report);
-      fs3.writeFileSync(jsonReportPath, JSON.stringify(report, null, 2), "utf-8");
+      this.log("Data injected into report", {
+        projectsCountAfterReconstruction: report.config?.projects?.length ?? 0
+      });
+      fs4.writeFileSync(jsonReportPath, JSON.stringify(report, null, 2), "utf-8");
+      this.log("Enriched report written to disk");
+      this.log("Collecting assets", { testResultsDir: this.options.testResultsDir });
       const assets = await this.assetCollector.collectAssets(report);
+      this.log("Assets collected", {
+        count: assets.length,
+        assets: assets.map((a) => ({ source: a.sourcePath, archive: a.archivePath, type: a.type }))
+      });
+      this.log("Creating ZIP archive", { outputPath: this.options.outputPath });
       const result = await this.zipper.createZip(jsonReportPath, assets);
+      this.log("ZIP created", {
+        zipPath: result.zipPath,
+        zipSize: result.size,
+        entriesCount: result.entries.length,
+        entries: result.entries.map((e) => ({ name: e.name, start: e.start, end: e.end }))
+      });
       if (this.testResults && this.testSession) {
+        this.log("Uploading results", { testSessionId: this.testSession.testSessionId });
         await this.uploadResults(report, result.zipPath, result.entries);
         if (!this.options.dryRun) {
           try {
-            fs3.unlinkSync(result.zipPath);
+            fs4.unlinkSync(result.zipPath);
           } catch (cleanupError) {
             console.warn(`[Checkly Reporter] Warning: Could not delete ZIP file: ${cleanupError}`);
           }
@@ -962,7 +1283,33 @@ var ChecklyReporter = class {
     console.log("\n======================================================");
   }
   /**
-   * Injects captured steps and warnings into the JSON report
+   * Extracts console messages and network requests from all captured traces
+   * Called before injecting data into the report
+   */
+  async extractDataFromTraces() {
+    const extractionPromises = [];
+    for (const [key, tracePath] of this.tracePathsMap.entries()) {
+      extractionPromises.push(
+        (async () => {
+          const reader = new TraceReader(tracePath);
+          if (!await reader.open()) return;
+          const messages = await reader.extractEvents('"type":"console"', toConsoleMessage);
+          if (messages.length > 0) {
+            this.consoleMessagesMap.set(key, messages);
+          }
+          const networkRequests = await reader.extractEvents('"type":"resource-snapshot"', toNetworkRequest);
+          if (networkRequests.length > 0) {
+            this.networkRequestsMap.set(key, networkRequests);
+          }
+        })().catch((error) => {
+          console.error(`[Checkly Reporter] Failed to extract data from trace: ${error}`);
+        })
+      );
+    }
+    await Promise.all(extractionPromises);
+  }
+  /**
+   * Injects captured steps, warnings, console messages, and network requests into the JSON report
    * Traverses the report structure and matches by test ID + retry
    */
   injectDataIntoReport(report) {
@@ -976,8 +1323,15 @@ var ChecklyReporter = class {
               result.steps = steps;
             }
             const warnings = this.warningsMap.get(key);
-            if (warnings && warnings.length > 0) {
-              result._checkly = { warnings };
+            const consoleMessages = this.consoleMessagesMap.get(key);
+            const networkRequests = this.networkRequestsMap.get(key);
+            const hasData = warnings && warnings.length > 0 || consoleMessages && consoleMessages.length > 0 || networkRequests && networkRequests.length > 0;
+            if (hasData) {
+              result._checkly = {
+                ...warnings && warnings.length > 0 ? { warnings } : {},
+                ...consoleMessages && consoleMessages.length > 0 ? { console: consoleMessages } : {},
+                ...networkRequests && networkRequests.length > 0 ? { network: networkRequests } : {}
+              };
             }
           }
         }
@@ -991,12 +1345,75 @@ var ChecklyReporter = class {
     for (const suite of report.suites) {
       processSuite(suite);
     }
+    this.reconstructProjectsFromTests(report);
+  }
+  /**
+   * Reconstructs config.projects and test.projectId from test data
+   * This is necessary for blob merge scenarios where Playwright's JSON reporter
+   * doesn't populate projects array or projectId fields
+   */
+  reconstructProjectsFromTests(report) {
+    const projectNames = /* @__PURE__ */ new Set();
+    let testsWithMissingProjectId = 0;
+    const configAny = report.config;
+    const originalProjectsCount = configAny.projects?.length ?? 0;
+    this.log("reconstructProjectsFromTests started", {
+      originalProjectsCount,
+      suitesCount: report.suites?.length ?? 0
+    });
+    const collectProjectNames = (suite) => {
+      for (const spec of suite.specs) {
+        for (const test of spec.tests) {
+          const testAny = test;
+          if (testAny.projectName) {
+            projectNames.add(testAny.projectName);
+          }
+          if (testAny.projectName && !testAny.projectId) {
+            testAny.projectId = testAny.projectName;
+            testsWithMissingProjectId++;
+          }
+        }
+      }
+      if (suite.suites) {
+        for (const nestedSuite of suite.suites) {
+          collectProjectNames(nestedSuite);
+        }
+      }
+    };
+    for (const suite of report.suites) {
+      collectProjectNames(suite);
+    }
+    this.log("Project names collected from tests", {
+      uniqueProjectNames: Array.from(projectNames),
+      testsWithMissingProjectId
+    });
+    if ((!configAny.projects || configAny.projects.length === 0) && projectNames.size > 0) {
+      configAny.projects = Array.from(projectNames).map((name) => ({
+        id: name,
+        name
+      }));
+      this.log("Reconstructed config.projects", {
+        reconstructedProjectsCount: configAny.projects.length,
+        projects: configAny.projects
+      });
+    } else {
+      this.log("No project reconstruction needed", {
+        reason: configAny.projects?.length > 0 ? "projects already present" : "no project names found in tests"
+      });
+    }
   }
   /**
    * Uploads test results to Checkly API
    */
-  async uploadResults(report, zipPath, entries) {
+  async uploadResults(_report, zipPath, entries) {
+    this.log("uploadResults started", {
+      zipPath,
+      entriesCount: entries.length,
+      hasTestResults: !!this.testResults,
+      hasTestSession: !!this.testSession
+    });
     if (!this.testResults || !this.testSession) {
+      this.log("uploadResults skipped - missing testResults or testSession");
       return;
     }
     try {
@@ -1005,25 +1422,42 @@ var ChecklyReporter = class {
       const isDegraded = failedCount === 0 && flakyCount > 0;
       const endTime = /* @__PURE__ */ new Date();
       const responseTime = this.startTime ? Math.max(0, endTime.getTime() - this.startTime.getTime()) : 0;
-      const zipSizeBytes = (await fs3.promises.stat(zipPath)).size;
+      const zipSizeBytes = (await fs4.promises.stat(zipPath)).size;
+      this.log("Upload metadata calculated", {
+        testCounts: this.testCounts,
+        overallStatus,
+        isDegraded,
+        responseTime,
+        zipSizeBytes,
+        testSessionId: this.testSession.testSessionId,
+        testResultsCount: this.testSession.testResults.length
+      });
       if (this.testSession.testResults.length > 0) {
         const firstResult = this.testSession.testResults[0];
+        this.log("Using first test result for upload", {
+          testResultId: firstResult.testResultId
+        });
         let assetId;
         if (zipSizeBytes > 0) {
+          this.log("Starting S3 asset upload", { zipSizeBytes });
           try {
-            const assets = fs3.createReadStream(zipPath);
+            const assets = fs4.createReadStream(zipPath);
             const uploadResponse = await this.testResults.uploadTestResultAsset(
               this.testSession.testSessionId,
               firstResult.testResultId,
               assets
             );
             assetId = uploadResponse.assetId;
+            this.log("S3 asset upload completed", { assetId });
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             console.error("[Checkly Reporter] Asset upload failed:", errorMessage);
+            this.log("S3 asset upload failed", { error: errorMessage });
           }
+        } else {
+          this.log("Skipping S3 upload - ZIP is empty");
         }
-        await this.testResults.updateTestResult(this.testSession.testSessionId, firstResult.testResultId, {
+        const updatePayload = {
           status: overallStatus,
           assetEntries: assetId ? entries : void 0,
           isDegraded,
@@ -1035,11 +1469,21 @@ var ChecklyReporter = class {
               s3PostTotalBytes: zipSizeBytes
             }
           }
+        };
+        this.log("Updating test result", {
+          testResultId: firstResult.testResultId,
+          payload: updatePayload,
+          assetEntriesCount: assetId ? entries.length : 0
         });
+        await this.testResults.updateTestResult(this.testSession.testSessionId, firstResult.testResultId, updatePayload);
+        this.log("Test result updated successfully");
+      } else {
+        this.log("No test results in session to update");
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error("[Checkly Reporter] Failed to upload results:", errorMessage);
+      this.log("uploadResults failed", { error: errorMessage });
     }
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkly/playwright-reporter",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Playwright reporter that generates ZIP archives containing JSON reports and test assets",
   "type": "module",
   "main": "dist/index.js",