@alternative-path/testlens-playwright-reporter 0.4.3 → 0.4.5

package/index.ts

@@ -6,7 +6,12 @@ import * as https from 'https';
 import axios, { AxiosInstance } from 'axios';
 import type { Reporter, TestCase, TestResult, FullConfig, Suite } from '@playwright/test/reporter';
 import { execSync } from 'child_process';
-import FormData from 'form-data';
+import pino from 'pino';
+
+// Create pino logger instance
+const logger = pino({
+  level: process.env.LOG_LEVEL || 'info'
+});
 
 // Lazy-load mime module to support ESM
 let mimeModule: any = null;
@@ -113,6 +118,7 @@ export interface RunMetadata {
   os: string;
   playwrightVersion: string;
   nodeVersion: string;
+  testlensVersion?: string;
   gitInfo?: GitInfo | null;
   shardInfo?: {
     current: number;
@@ -184,6 +190,7 @@ export class TestLensReporter implements Reporter {
   private testMap: Map<string, TestData>;
   private runCreationFailed: boolean = false; // Track if run creation failed due to limits
   private cliArgs: Record<string, any> = {}; // Store CLI args separately
+  private pendingUploads: Set<Promise<any>> = new Set(); // Track pending artifact uploads
 
   /**
    * Parse custom metadata from environment variables
@@ -212,10 +219,10 @@ export class TestLensReporter implements Reporter {
           // For testlensBuildTag, support comma-separated values
           if (key === 'testlensBuildTag' && value.includes(',')) {
             customArgs[key] = value.split(',').map(tag => tag.trim()).filter(tag => tag);
-            console.log(`✓ Found ${envVar}=${value} (mapped to '${key}' as array of ${customArgs[key].length} tags)`);
+            logger.info(`✓ Found ${envVar}=${value} (mapped to '${key}' as array of ${customArgs[key].length} tags)`);
           } else {
             customArgs[key] = value;
-            console.log(`✓ Found ${envVar}=${value} (mapped to '${key}')`);
+            logger.info(`✓ Found ${envVar}=${value} (mapped to '${key}')`);
           }
           break; // Use first match
         }
@@ -255,6 +262,8 @@ export class TestLensReporter implements Reporter {
       flushInterval: options.flushInterval || 5000,
       retryAttempts: options.retryAttempts !== undefined ? options.retryAttempts : 0,
       timeout: options.timeout || 60000,
+      rejectUnauthorized: options.rejectUnauthorized,
+      ignoreSslErrors: options.ignoreSslErrors,
       customMetadata: { ...options.customMetadata, ...customArgs } // Config metadata first, then CLI args override
     } as Required<TestLensReporterConfig>;
 
@@ -263,27 +272,36 @@ export class TestLensReporter implements Reporter {
     }
     
     if (apiKey !== options.apiKey) {
-      console.log('✓ Using API key from environment variable');
+      logger.info('✓ Using API key from environment variable');
+    }
+
+    // Default environment to allow self-signed certs unless explicitly set
+    if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === undefined) {
+      process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
     }
 
     // Determine SSL validation behavior
-    let rejectUnauthorized = true; // Default to secure
+    let rejectUnauthorized = process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0'; // Default to secure unless explicitly disabled
 
-    // Check various ways SSL validation can be disabled (in order of precedence)
-    if (this.config.ignoreSslErrors) {
-      // Explicit configuration option
+    // Check various ways SSL validation can be disabled or enforced (in order of precedence)
+    if (this.config.ignoreSslErrors === true) {
       rejectUnauthorized = false;
-      console.log('⚠️  SSL certificate validation disabled via ignoreSslErrors option');
+      logger.warn('[WARN] SSL certificate validation disabled via ignoreSslErrors option');
     } else if (this.config.rejectUnauthorized === false) {
-      // Explicit configuration option
       rejectUnauthorized = false;
-      console.log('⚠️  SSL certificate validation disabled via rejectUnauthorized option');
+      logger.warn('[WARN] SSL certificate validation disabled via rejectUnauthorized option');
+    } else if (this.config.rejectUnauthorized === true) {
+      rejectUnauthorized = true;
     } else if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0') {
-      // Environment variable override
       rejectUnauthorized = false;
-      console.log('⚠️  SSL certificate validation disabled via NODE_TLS_REJECT_UNAUTHORIZED environment variable');
+      logger.warn('[WARN] SSL certificate validation disabled via NODE_TLS_REJECT_UNAUTHORIZED environment variable');
+    } else if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '1') {
+      rejectUnauthorized = true;
     }
 
+    // Mirror the resolved value so all HTTPS requests in this process follow it
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = rejectUnauthorized ? '1' : '0';
+
     // Set up axios instance with retry logic and enhanced SSL handling
     this.axiosInstance = axios.create({
       baseURL: this.config.apiEndpoint,
@@ -331,11 +349,11 @@ export class TestLensReporter implements Reporter {
     
     // Log custom metadata if any
     if (this.config.customMetadata && Object.keys(this.config.customMetadata).length > 0) {
-      console.log('\n📋 Custom Metadata Detected:');
+      logger.info('\n[METADATA] Custom Metadata Detected:');
       Object.entries(this.config.customMetadata).forEach(([key, value]) => {
-        console.log(`   ${key}: ${value}`);
+        logger.info(`   ${key}: ${value}`);
       });
-      console.log('');
+      logger.info('');
     }
   }
 
@@ -347,7 +365,8 @@ export class TestLensReporter implements Reporter {
       browser: 'multiple',
       os: `${os.type()} ${os.release()}`,
       playwrightVersion: this.getPlaywrightVersion(),
-      nodeVersion: process.version
+      nodeVersion: process.version,
+      testlensVersion: this.getTestLensVersion()
     };
     
     // Add custom metadata if provided
@@ -374,6 +393,15 @@ export class TestLensReporter implements Reporter {
     }
   }
 
+  private getTestLensVersion(): string {
+    try {
+      const testlensPackage = require('./package.json');
+      return testlensPackage.version;
+    } catch (error) {
+      return 'unknown';
+    }
+  }
+
   private normalizeTestStatus(status: string): string {
     // Treat timeout as failed for consistency with analytics
     if (status === 'timedOut') {
@@ -397,22 +425,22 @@ export class TestLensReporter implements Reporter {
   async onBegin(config: FullConfig, suite: Suite): Promise<void> {
     // Show Build Name if provided, otherwise show Run ID
     if (this.runMetadata.testlensBuildName) {
-      console.log(`🚀 TestLens Reporter starting - Build: ${this.runMetadata.testlensBuildName}`);
-      console.log(`   Run ID: ${this.runId}`);
+      logger.info(`🚀 TestLens Reporter starting - Build: ${this.runMetadata.testlensBuildName}`);
+      logger.info(`   Run ID: ${this.runId}`);
     } else {
-      console.log(`🚀 TestLens Reporter starting - Run ID: ${this.runId}`);
+      logger.info(`🚀 TestLens Reporter starting - Run ID: ${this.runId}`);
     }
     
     // Collect Git information if enabled
     if (this.config.enableGitInfo) {
       this.runMetadata.gitInfo = await this.collectGitInfo();
       if (this.runMetadata.gitInfo) {
-        console.log(`📦 Git info collected: branch=${this.runMetadata.gitInfo.branch}, commit=${this.runMetadata.gitInfo.shortCommit}, author=${this.runMetadata.gitInfo.author}`);
+        logger.info(`📦 Git info collected: branch=${this.runMetadata.gitInfo.branch}, commit=${this.runMetadata.gitInfo.shortCommit}, author=${this.runMetadata.gitInfo.author}`);
       } else {
-        console.log(`⚠️  Git info collection returned null - not in a git repository or git not available`);
+        logger.warn(`[WARN] Git info collection returned null - not in a git repository or git not available`);
       }
     } else {
-      console.log(`ℹ️  Git info collection disabled (enableGitInfo: false)`);
+      logger.info(`[INFO] Git info collection disabled (enableGitInfo: false)`);
     }
 
     // Add shard information if available
@@ -434,7 +462,7 @@ export class TestLensReporter implements Reporter {
 
   async onTestBegin(test: TestCase, result: TestResult): Promise<void> {
     // Log which test is starting
-    console.log(`\n▶️  Running test: ${test.title}`);
+    logger.info(`\n[TEST] Running test: ${test.title}`);
     
     const specPath = test.location.file;
     const specKey = `${specPath}-${test.parent.title}`;
@@ -515,11 +543,11 @@ export class TestLensReporter implements Reporter {
     const testId = this.getTestId(test);
     let testData = this.testMap.get(testId);
 
-    console.log(`[TestLens] onTestEnd called for test: ${test.title}, status: ${result.status}, testData exists: ${!!testData}`);
+    logger.info(`[TestLens] onTestEnd called for test: ${test.title}, status: ${result.status}, testData exists: ${!!testData}`);
 
     // For skipped tests, onTestBegin might not be called, so we need to create the test data here
     if (!testData) {
-      console.log(`[TestLens] Creating test data for skipped/uncreated test: ${test.title}`);
+      logger.info(`[TestLens] Creating test data for skipped/uncreated test: ${test.title}`);
       // Create spec data if not exists (skipped tests might not have spec data either)
       const specPath = test.location.file;
       const specKey = `${specPath}-${test.parent.title}`;
@@ -683,25 +711,21 @@ export class TestLensReporter implements Reporter {
         return testError;
       });
 
-      // Only send testEnd event after final retry attempt
-      // If test passed or this is the last retry, send the event
-      const isFinalAttempt = result.status === 'passed' || result.status === 'skipped' || result.retry >= test.retries;
-      
-      if (isFinalAttempt) {
-        console.log(`[TestLens] Sending testEnd - testId: ${testData.id}, status: ${testData.status}, originalStatus: ${testData.originalStatus}`);
-        // Send test end event to API and get response
-        const testEndResponse = await this.sendToApi({
-          type: 'testEnd',
-          runId: this.runId,
-          timestamp: new Date().toISOString(),
-          test: testData
-        });
+      // Send testEnd event for all tests, regardless of status
+      // This ensures tests that are interrupted or have unexpected statuses are properly recorded
+      logger.info(`[TestLens] Sending testEnd - testId: ${testData.id}, status: ${testData.status}, originalStatus: ${testData.originalStatus}`);
+      // Send test end event to API and get response
+      const testEndResponse = await this.sendToApi({
+        type: 'testEnd',
+        runId: this.runId,
+        timestamp: new Date().toISOString(),
+        test: testData
+      });
 
-        // Handle artifacts (test case is now guaranteed to be in database)
-        if (this.config.enableArtifacts) {
-          // Pass test case DB ID if available for faster lookups
-          await this.processArtifacts(testId, result, testEndResponse?.testCaseId);
-        }
+      // Handle artifacts (test case is now guaranteed to be in database)
+      if (this.config.enableArtifacts) {
+        // Pass test case DB ID if available for faster lookups
+        await this.processArtifacts(testId, result, testEndResponse?.testCaseId);
       }
     }
 
@@ -718,13 +742,33 @@ export class TestLensReporter implements Reporter {
       }
 
       // Check if all tests in spec are complete
+      // Only consider tests that were actually executed (have testData)
       const remainingTests = test.parent.tests.filter((t: any) => {
         const tId = this.getTestId(t);
         const tData = this.testMap.get(tId);
-        return !tData || !tData.endTime;
+        // If testData exists but no endTime, it's still running
+        return tData && !tData.endTime;
       });
 
       if (remainingTests.length === 0) {
+        // Determine final spec status based on all executed tests
+        const executedTests = test.parent.tests
+          .map((t: any) => {
+            const tId = this.getTestId(t);
+            return this.testMap.get(tId);
+          })
+          .filter((tData: TestData | undefined): tData is TestData => !!tData);
+        
+        if (executedTests.length > 0) {
+          const allTestStatuses = executedTests.map(tData => tData.status);
+          if (allTestStatuses.every(status => status === 'passed')) {
+            specData.status = 'passed';
+          } else if (allTestStatuses.some(status => status === 'failed')) {
+            specData.status = 'failed';
+          } else if (allTestStatuses.every(status => status === 'skipped')) {
+            specData.status = 'skipped';
+          }
+        }
         // Aggregate tags from all tests in this spec
         const allTags = new Set<string>();
         test.parent.tests.forEach((t: any) => {
@@ -757,6 +801,17 @@ export class TestLensReporter implements Reporter {
     this.runMetadata.endTime = new Date().toISOString();
     this.runMetadata.duration = Date.now() - new Date(this.runMetadata.startTime).getTime();
 
+    // Wait for all pending artifact uploads to complete before sending runEnd
+    if (this.pendingUploads.size > 0) {
+      logger.info(`⏳ Waiting for ${this.pendingUploads.size} artifact upload(s) to complete...`);
+      try {
+        await Promise.all(Array.from(this.pendingUploads));
+        logger.info(`[OK] All artifact uploads completed`);
+      } catch (error) {
+        logger.error(`[WARN] Some artifact uploads failed, continuing with runEnd`);
+      }
+    }
+
     // Calculate final stats
     const totalTests = Array.from(this.testMap.values()).length;
     const passedTests = Array.from(this.testMap.values()).filter(t => t.status === 'passed').length;
@@ -788,12 +843,12 @@ export class TestLensReporter implements Reporter {
 
     // Show Build Name if provided, otherwise show Run ID
     if (this.runMetadata.testlensBuildName) {
-      console.log(`📊 TestLens Report completed - Build: ${this.runMetadata.testlensBuildName}`);
-      console.log(`   Run ID: ${this.runId}`);
+      logger.info(`[COMPLETE] TestLens Report completed - Build: ${this.runMetadata.testlensBuildName}`);
+      logger.info(`   Run ID: ${this.runId}`);
     } else {
-      console.log(`📊 TestLens Report completed - Run ID: ${this.runId}`);
+      logger.info(`[COMPLETE] TestLens Report completed - Run ID: ${this.runId}`);
     }
-    console.log(`🎯 Results: ${passedTests} passed, ${failedTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
+    logger.info(`[RESULTS] ${passedTests} passed, ${failedTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
   }
 
   private async sendToApi(payload: any): Promise<any> {
@@ -809,7 +864,7 @@ export class TestLensReporter implements Reporter {
         }
       });
       if (this.config.enableRealTimeStream) {
-        console.log(`✅ Sent ${payload.type} event to TestLens (HTTP ${response.status})`);
+        logger.info(`[OK] Sent ${payload.type} event to TestLens (HTTP ${response.status})`);
       }
       // Return response data for caller to use
       return response.data;
@@ -824,25 +879,25 @@ export class TestLensReporter implements Reporter {
           this.runCreationFailed = true;
         }
         
-        console.error('\n' + '='.repeat(80));
+        logger.error('\n' + '='.repeat(80));
         if (errorData?.limit_type === 'test_cases') {
-          console.error('❌ TESTLENS ERROR: Test Cases Limit Reached');
+          logger.error('[ERROR] TESTLENS ERROR: Test Cases Limit Reached');
         } else if (errorData?.limit_type === 'test_runs') {
-          console.error('❌ TESTLENS ERROR: Test Runs Limit Reached');
+          logger.error('[ERROR] TESTLENS ERROR: Test Runs Limit Reached');
         } else {
-          console.error('❌ TESTLENS ERROR: Plan Limit Reached');
+          logger.error('[ERROR] TESTLENS ERROR: Plan Limit Reached');
         }
-        console.error('='.repeat(80));
-        console.error('');
-        console.error(errorData?.message || 'You have reached your plan limit.');
-        console.error('');
-        console.error(`Current usage: ${errorData?.current_usage || 'N/A'} / ${errorData?.limit || 'N/A'}`);
-        console.error('');
-        console.error('To continue, please upgrade your plan.');
-        console.error('Contact: support@alternative-path.com');
-        console.error('');
-        console.error('='.repeat(80));
-        console.error('');
+        logger.error('='.repeat(80));
+        logger.error('');
+        logger.error(errorData?.message || 'You have reached your plan limit.');
+        logger.error('');
+        logger.error(`Current usage: ${errorData?.current_usage || 'N/A'} / ${errorData?.limit || 'N/A'}`);
+        logger.error('');
+        logger.error('To continue, please upgrade your plan.');
+        logger.error('Contact: support@alternative-path.com');
+        logger.error('');
+        logger.error('='.repeat(80));
+        logger.error('');
         return; // Don't log the full error object for limit errors
       }
       
@@ -850,36 +905,37 @@ export class TestLensReporter implements Reporter {
       if (status === 401) {
         if (errorData?.error === 'trial_expired' || errorData?.error === 'subscription_inactive' || 
             errorData?.error === 'test_cases_limit_reached' || errorData?.error === 'test_runs_limit_reached') {
-          console.error('\n' + '='.repeat(80));
+          logger.error('\n' + '='.repeat(80));
           
           if (errorData?.error === 'test_cases_limit_reached') {
-            console.error('❌ TESTLENS ERROR: Test Cases Limit Reached');
+            logger.error('[ERROR] TESTLENS ERROR: Test Cases Limit Reached');
           } else if (errorData?.error === 'test_runs_limit_reached') {
-            console.error('❌ TESTLENS ERROR: Test Runs Limit Reached');
+            logger.error('[ERROR] TESTLENS ERROR: Test Runs Limit Reached');
           } else {
-            console.error('❌ TESTLENS ERROR: Your trial plan has ended');
+            logger.error('[ERROR] TESTLENS ERROR: Your trial plan has ended');
           }
           
-          console.error('='.repeat(80));
-          console.error('');
-          console.error(errorData?.message || 'Your trial period has expired.');
-          console.error('');
-          console.error('To continue using TestLens, please upgrade to Enterprise plan.');
-          console.error('Contact: ' + (errorData?.contactEmail || 'support@alternative-path.com'));
-          console.error('');
+          logger.error('='.repeat(80));
+          logger.error('');
+          logger.error(errorData?.message || 'Your trial period has expired.');
+          logger.error('');
+          logger.error('To continue using TestLens, please upgrade to Enterprise plan.');
+          logger.error('Contact: ' + (errorData?.contactEmail || 'support@alternative-path.com'));
+          logger.error('');
           if (errorData?.trial_end_date) {
-            console.error(`Trial ended: ${new Date(errorData.trial_end_date).toLocaleDateString()}`);
-            console.error('');
+            logger.error(`Trial ended: ${new Date(errorData.trial_end_date).toLocaleDateString()}`);
+            logger.error('');
           }
-          console.error('='.repeat(80));
-          console.error('');
+          logger.error('='.repeat(80));
+          logger.error('');
         } else {
-          console.error(`❌ Authentication failed: ${errorData?.error || 'Invalid API key'}`);
+          logger.error(`[ERROR] Authentication failed: ${errorData?.error || 'Invalid API key'}`);
         }
       } else if (status !== 403) {
         // Log other errors (but not 403 which we handled above)
-        console.error(`❌ Failed to send ${payload.type} event to TestLens:`, {
-          message: error?.message || 'Unknown error',
+        logger.error({
+          message: `[ERROR] Failed to send ${payload.type} event to TestLens`,
+          error: error?.message || 'Unknown error',
           status: status,
           statusText: error?.response?.statusText,
           data: errorData,
@@ -910,13 +966,13 @@ export class TestLensReporter implements Reporter {
         
         // Skip video if disabled in config
         if (isVideo && !this.config.enableVideo) {
-          console.log(`⏭️  Skipping video artifact ${attachment.name} - video capture disabled in config`);
+          logger.info(`[SKIP] Skipping video artifact ${attachment.name} - video capture disabled in config`);
           continue;
         }
         
         // Skip screenshot if disabled in config
         if (isScreenshot && !this.config.enableScreenshot) {
-          console.log(`⏭️  Skipping screenshot artifact ${attachment.name} - screenshot capture disabled in config`);
+          logger.info(`[SKIP] Skipping screenshot artifact ${attachment.name} - screenshot capture disabled in config`);
           continue;
         }
         
@@ -952,37 +1008,58 @@ export class TestLensReporter implements Reporter {
           }
 
           // Upload to S3 first (pass DB ID if available for faster lookup)
-          const s3Data = await this.uploadArtifactToS3(attachment.path, testId, fileName, testCaseDbId);
-          
-          // Skip if upload failed or file was too large
-          if (!s3Data) {
-            console.log(`⏭️  [Test: ${testId.substring(0, 8)}...] Skipping artifact ${attachment.name} - upload failed or file too large`);
-            continue;
-          }
-          
-          const artifactData = {
-            testId,
-            type: this.getArtifactType(attachment.name),
-            path: attachment.path,
-            name: fileName,
-            contentType: attachment.contentType,
-            fileSize: this.getFileSize(attachment.path),
-            storageType: 's3',
-            s3Key: s3Data.key,
-            s3Url: s3Data.url
-          };
+          // Create upload promise that we can track
+          const uploadPromise = Promise.resolve().then(async () => {
+            try {
+              if (!attachment.path) {
+                logger.info(`[SKIP] [Test: ${testId.substring(0, 8)}...] Skipping artifact ${attachment.name} - no file path`);
+                return;
+              }
+              
+              const s3Data = await this.uploadArtifactToS3(attachment.path, testId, fileName, testCaseDbId);
+              
+              // Skip if upload failed or file was too large
+              if (!s3Data) {
+                logger.info(`[SKIP] [Test: ${testId.substring(0, 8)}...] Skipping artifact ${attachment.name} - upload failed or file too large`);
+                return;
+              }
+              
+              const artifactData = {
+                testId,
+                type: this.getArtifactType(attachment.name),
+                path: attachment.path,
+                name: fileName,
+                contentType: attachment.contentType,
+                fileSize: this.getFileSize(attachment.path),
+                storageType: 's3',
+                s3Key: s3Data.key,
+                s3Url: s3Data.url
+              };
 
-          // Send artifact data to API
-          await this.sendToApi({
-            type: 'artifact',
-            runId: this.runId,
-            timestamp: new Date().toISOString(),
-            artifact: artifactData
+              // Send artifact data to API
+              await this.sendToApi({
+                type: 'artifact',
+                runId: this.runId,
+                timestamp: new Date().toISOString(),
+                artifact: artifactData
+              });
+              
+              logger.info(`[ARTIFACT] [Test: ${testId.substring(0, 8)}...] Processed artifact: ${fileName}`);
+            } catch (error) {
+              logger.error(`[ERROR] [Test: ${testId.substring(0, 8)}...] Failed to process artifact ${attachment.name}: ${(error as Error).message}`);
+            }
           });
           
-          console.log(`📎 [Test: ${testId.substring(0, 8)}...] Processed artifact: ${fileName}`);
+          // Track this upload and ensure cleanup on completion
+          this.pendingUploads.add(uploadPromise);
+          uploadPromise.finally(() => {
+            this.pendingUploads.delete(uploadPromise);
+          });
+          
+          // Don't await here - let uploads happen in parallel
+          // They will be awaited in onEnd
         } catch (error) {
-          console.error(`❌ [Test: ${testId.substring(0, 8)}...] Failed to process artifact ${attachment.name}:`, (error as Error).message);
+          logger.error(`[ERROR] [Test: ${testId.substring(0, 8)}...] Failed to setup artifact upload ${attachment.name}: ${(error as Error).message}`);
         }
       }
     }
@@ -1003,8 +1080,13 @@ export class TestLensReporter implements Reporter {
       }));
       
       // Send to dedicated spec code blocks API endpoint
-      const baseUrl = this.config.apiEndpoint.replace('/webhook/playwright', '');
-      const specEndpoint = `${baseUrl}/webhook/playwright/spec-code-blocks`;
+      // Extract base URL - handle both full and partial endpoint patterns
+      let baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
+      if (baseUrl === this.config.apiEndpoint) {
+        // Fallback: try alternative pattern if main pattern didn't match
+        baseUrl = this.config.apiEndpoint.replace('/webhook/playwright', '');
+      }
+      const specEndpoint = `${baseUrl}/api/v1/webhook/playwright/spec-code-blocks`;
       
       await this.axiosInstance.post(specEndpoint, {
         filePath: path.relative(process.cwd(), specPath),
@@ -1012,17 +1094,17 @@ export class TestLensReporter implements Reporter {
         testSuiteName: path.basename(specPath).replace(/\.(spec|test)\.(js|ts)$/, '')
       });
 
-      console.log(`📝 Sent ${codeBlocks.length} code blocks for: ${path.basename(specPath)}`);
+      logger.info(`📝 Sent ${codeBlocks.length} code blocks for: ${path.basename(specPath)}`);
     } catch (error: any) {
       const errorData = error?.response?.data;
       
       // Handle duplicate spec code blocks gracefully (when re-running tests)
       if (errorData?.error && errorData.error.includes('duplicate key value violates unique constraint')) {
-        console.log(`ℹ️  Spec code blocks already exist for: ${path.basename(specPath)} (skipped)`);
+        logger.info(`[INFO] Spec code blocks already exist for: ${path.basename(specPath)} (skipped)`);
         return;
       }
       
-      console.error('Failed to send spec code blocks:', errorData || error?.message || 'Unknown error');
+      logger.error(`Failed to send spec code blocks: ${errorData || error?.message || 'Unknown error'}`);
     }
   }
 
@@ -1088,7 +1170,7 @@ export class TestLensReporter implements Reporter {
       
       return blocks;
     } catch (error: any) {
-      console.error(`Failed to extract test blocks from ${filePath}:`, error.message);
+      logger.error(`Failed to extract test blocks from ${filePath}: ${error.message}`);
       return [];
     }
   }
@@ -1112,7 +1194,7 @@ export class TestLensReporter implements Reporter {
         }
       } catch (e) {
         // Remote info is optional - handle gracefully
-        console.log('ℹ️  No git remote configured, skipping remote info');
+        logger.info('[INFO] No git remote configured, skipping remote info');
       }
       
       const isDirty = execSync('git status --porcelain', { encoding: 'utf-8' }).trim().length > 0;
@@ -1193,7 +1275,7 @@ export class TestLensReporter implements Reporter {
       const fileSize = this.getFileSize(filePath);
       const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
       
-      console.log(`📤 Uploading ${fileName} (${fileSizeMB}MB) directly to S3...`);
+      logger.info(`📤 Uploading ${fileName} (${fileSizeMB}MB) directly to S3...`);
 
       const baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
       
@@ -1225,7 +1307,7 @@ export class TestLensReporter implements Reporter {
       const { uploadUrl, s3Key, metadata } = presignedResponse.data;
       
       // Step 2: Upload directly to S3 using presigned URL
-      console.log(`⬆️  [Test: ${testId.substring(0, 8)}...] Uploading ${fileName} directly to S3...`);
+      logger.info(`[UPLOAD] [Test: ${testId.substring(0, 8)}...] Uploading ${fileName} directly to S3...`);
       
       const fileBuffer = fs.readFileSync(filePath);
       
@@ -1247,7 +1329,7 @@ export class TestLensReporter implements Reporter {
         throw new Error(`S3 upload failed with status ${uploadResponse.status}`);
       }
 
-      console.log(`✅ [Test: ${testId.substring(0, 8)}...] S3 upload completed for ${fileName}`);
+      logger.info(`[OK] [Test: ${testId.substring(0, 8)}...] S3 upload completed for ${fileName}`);
 
       // Step 3: Confirm upload with server to save metadata
       const confirmEndpoint = `${baseUrl}/api/v1/artifacts/public/confirm-upload`;
@@ -1273,7 +1355,7 @@ export class TestLensReporter implements Reporter {
 
       if (confirmResponse.status === 201 && confirmResponse.data.success) {
         const artifact = confirmResponse.data.artifact;
-        console.log(`✅ [Test: ${testId.substring(0, 8)}...] Upload confirmed${testCaseDbId ? ' (fast path)' : ' (fallback)'}`);
+        logger.info(`[OK] [Test: ${testId.substring(0, 8)}...] Upload confirmed${testCaseDbId ? ' (fast path)' : ' (fallback)'}`);
         return {
           key: s3Key,
           url: artifact.s3Url,
@@ -1291,29 +1373,29 @@ export class TestLensReporter implements Reporter {
         
         if (errorData?.error === 'trial_expired' || errorData?.error === 'subscription_inactive' ||
             errorData?.error === 'test_cases_limit_reached' || errorData?.error === 'test_runs_limit_reached') {
-          console.error('\\n' + '='.repeat(80));
+          logger.error('\n' + '='.repeat(80));
           
           if (errorData?.error === 'test_cases_limit_reached') {
-            console.error('❌ TESTLENS ERROR: Test Cases Limit Reached');
+            logger.error('[ERROR] TESTLENS ERROR: Test Cases Limit Reached');
           } else if (errorData?.error === 'test_runs_limit_reached') {
-            console.error('❌ TESTLENS ERROR: Test Runs Limit Reached');
+            logger.error('[ERROR] TESTLENS ERROR: Test Runs Limit Reached');
           } else {
-            console.error('❌ TESTLENS ERROR: Your trial plan has ended');
+            logger.error('[ERROR] TESTLENS ERROR: Your trial plan has ended');
           }
           
-          console.error('='.repeat(80));
-          console.error('');
-          console.error(errorData?.message || 'Your trial period has expired.');
-          console.error('');
-          console.error('To continue using TestLens, please upgrade to Enterprise plan.');
-          console.error('Contact: ' + (errorData?.contactEmail || 'support@alternative-path.com'));
-          console.error('');
+          logger.error('='.repeat(80));
+          logger.error('');
+          logger.error(errorData?.message || 'Your trial period has expired.');
+          logger.error('');
+          logger.error('To continue using TestLens, please upgrade to Enterprise plan.');
+          logger.error('Contact: ' + (errorData?.contactEmail || 'support@alternative-path.com'));
+          logger.error('');
           if (errorData?.trial_end_date) {
-            console.error(`Trial ended: ${new Date(errorData.trial_end_date).toLocaleDateString()}`);
-            console.error('');
+            logger.error(`Trial ended: ${new Date(errorData.trial_end_date).toLocaleDateString()}`);
+            logger.error('');
           }
-          console.error('='.repeat(80));
-          console.error('');
+          logger.error('='.repeat(80));
+          logger.error('');
           return null;
         }
       }
@@ -1331,9 +1413,9 @@ export class TestLensReporter implements Reporter {
         errorMsg = `Access denied (403) - presigned URL may have expired`;
       }
       
-      console.error(`❌ Failed to upload ${fileName} to S3:`, errorMsg);
+      logger.error(`[ERROR] Failed to upload ${fileName} to S3: ${errorMsg}`);
       if (error.response?.data) {
-        console.error('Error details:', error.response.data);
+        logger.error({ errorDetails: error.response.data }, 'Error details');
       }
       
       // Don't throw, just return null to continue with other artifacts
@@ -1352,7 +1434,7 @@ export class TestLensReporter implements Reporter {
         return mimeType || 'application/octet-stream';
       }
     } catch (error: any) {
-      console.warn(`Failed to get MIME type for ${fileName}:`, error.message);
+      logger.warn(`Failed to get MIME type for ${fileName}: ${error.message}`);
     }
     // Fallback to basic content type mapping
     const contentTypes: Record<string, string> = {
@@ -1372,36 +1454,19 @@ export class TestLensReporter implements Reporter {
     return contentTypes[ext] || 'application/octet-stream';
   }
 
-  private generateS3Key(runId: string, testId: string, fileName: string): string {
-    const date = new Date().toISOString().slice(0, 10);
-    const safeTestId = this.sanitizeForS3(testId);
-    const safeFileName = this.sanitizeForS3(fileName);
-    const ext = path.extname(fileName);
-    const baseName = path.basename(fileName, ext);
-    
-    return `test-artifacts/${date}/${runId}/${safeTestId}/${safeFileName}${ext}`;
-  }
-
-  private sanitizeForS3(value: string): string {
-    return value
-      .replace(/[\/:*?"<>|]/g, '-')
-      .replace(/[-\u001f\u007f]/g, '-')
-      .replace(/[^-~]/g, '-')
-      .replace(/\s+/g, '-')
-      .replace(/[_]/g, '-')
-      .replace(/-+/g, '-')
-      .replace(/^-|-$/g, '');
-  }
+  // Note: S3 key generation and sanitization are handled server-side
+  // generateS3Key() and sanitizeForS3() methods removed as they were not used
 
   private getFileSize(filePath: string): number {
     try {
       const stats = fs.statSync(filePath);
       return stats.size;
     } catch (error) {
-      console.warn(`Could not get file size for ${filePath}:`, (error as Error).message);
+      logger.warn(`Could not get file size for ${filePath}: ${(error as Error).message}`);
       return 0;
     }
   }
 }
 
 export default TestLensReporter;
+