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

package/index.js

@@ -9,6 +9,11 @@ const fs = tslib_1.__importStar(require("fs"));
 const https = tslib_1.__importStar(require("https"));
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const child_process_1 = require("child_process");
+const pino_1 = tslib_1.__importDefault(require("pino"));
+// Create pino logger instance
+const logger = (0, pino_1.default)({
+    level: process.env.LOG_LEVEL || 'info'
+});
 // Lazy-load mime module to support ESM
 let mimeModule = null;
 async function getMime() {
@@ -45,11 +50,11 @@ class TestLensReporter {
                     // 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
                 }
@@ -60,6 +65,7 @@ class TestLensReporter {
     constructor(options) {
         this.runCreationFailed = false; // Track if run creation failed due to limits
         this.cliArgs = {}; // Store CLI args separately
+        this.pendingUploads = new Set(); // Track pending artifact uploads
         // Parse custom CLI arguments
         const customArgs = TestLensReporter.parseCustomArgs();
         this.cliArgs = customArgs; // Store CLI args separately for later use
@@ -87,32 +93,43 @@ class TestLensReporter {
             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
         };
         if (!this.config.apiKey) {
             throw new Error('API_KEY is required for TestLensReporter. Pass it as apiKey option in your playwright config or set one of these environment variables: TESTLENS_API_KEY, TESTLENS_KEY, PLAYWRIGHT_API_KEY, PW_API_KEY, API_KEY, or APIKEY.');
         }
         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
-        // Check various ways SSL validation can be disabled (in order of precedence)
-        if (this.config.ignoreSslErrors) {
-            // Explicit configuration option
+        let rejectUnauthorized = process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0'; // Default to secure unless explicitly disabled
+        // 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_1.default.create({
             baseURL: this.config.apiEndpoint,
@@ -151,11 +168,11 @@ class TestLensReporter {
         this.runCreationFailed = false;
         // 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('');
         }
     }
     initializeRunMetadata() {
@@ -166,7 +183,8 @@ class TestLensReporter {
             browser: 'multiple',
             os: `${os.type()} ${os.release()}`,
             playwrightVersion: this.getPlaywrightVersion(),
-            nodeVersion: process.version
+            nodeVersion: process.version,
+            testlensVersion: this.getTestLensVersion()
         };
         // Add custom metadata if provided
         if (this.config.customMetadata && Object.keys(this.config.customMetadata).length > 0) {
@@ -189,6 +207,15 @@ class TestLensReporter {
             return 'unknown';
         }
     }
+    getTestLensVersion() {
+        try {
+            const testlensPackage = require('./package.json');
+            return testlensPackage.version;
+        }
+        catch (error) {
+            return 'unknown';
+        }
+    }
     normalizeTestStatus(status) {
         // Treat timeout as failed for consistency with analytics
         if (status === 'timedOut') {
@@ -210,24 +237,24 @@ class TestLensReporter {
     async onBegin(config, suite) {
         // 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
         if (config.shard) {
@@ -246,7 +273,7 @@ class TestLensReporter {
     }
     async onTestBegin(test, result) {
         // 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}`;
         // Create or update spec data
@@ -319,10 +346,10 @@ class TestLensReporter {
     async onTestEnd(test, result) {
         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}`;
@@ -465,23 +492,20 @@ class TestLensReporter {
                 }
                 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
-                });
-                // 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);
-                }
+            // 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);
             }
         }
         // Update spec status
@@ -497,12 +521,33 @@ class TestLensReporter {
                 specData.status = 'skipped';
             }
             // Check if all tests in spec are complete
+            // Only consider tests that were actually executed (have testData)
             const remainingTests = test.parent.tests.filter((t) => {
                 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) => {
+                    const tId = this.getTestId(t);
+                    return this.testMap.get(tId);
+                })
+                    .filter((tData) => !!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();
                 test.parent.tests.forEach((t) => {
@@ -530,6 +575,17 @@ class TestLensReporter {
     async onEnd(result) {
         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;
@@ -558,13 +614,13 @@ class TestLensReporter {
         });
         // 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`);
     }
     async sendToApi(payload) {
         // Skip sending if run creation already failed
@@ -578,7 +634,7 @@ class TestLensReporter {
                 }
             });
             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;
@@ -592,65 +648,66 @@ class TestLensReporter {
                 if (payload.type === 'runStart' && errorData?.limit_type === 'test_runs') {
                     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
             }
             // Check for trial expiration, subscription errors, or limit errors (401)
             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,
@@ -676,12 +733,12 @@ class TestLensReporter {
                 const isScreenshot = artifactType === 'screenshot' || attachment.contentType?.startsWith('image/');
                 // 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;
                 }
                 try {
@@ -715,34 +772,53 @@ class TestLensReporter {
                         }
                     }
                     // 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
-                    };
-                    // Send artifact data to API
-                    await this.sendToApi({
-                        type: 'artifact',
-                        runId: this.runId,
-                        timestamp: new Date().toISOString(),
-                        artifact: artifactData
+                    // 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
+                            });
+                            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.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.message);
+                    logger.error(`[ERROR] [Test: ${testId.substring(0, 8)}...] Failed to setup artifact upload ${attachment.name}: ${error.message}`);
                 }
             }
         }
@@ -760,23 +836,28 @@ class TestLensReporter {
                 describe: block.describe // parent describe block name
             }));
             // 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),
                 codeBlocks,
                 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) {
             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'}`);
         }
     }
     extractTestBlocks(filePath) {
@@ -835,7 +916,7 @@ class TestLensReporter {
             return blocks;
         }
         catch (error) {
-            console.error(`Failed to extract test blocks from ${filePath}:`, error.message);
+            logger.error(`Failed to extract test blocks from ${filePath}: ${error.message}`);
             return [];
         }
     }
@@ -858,7 +939,7 @@ class TestLensReporter {
             }
             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 = (0, child_process_1.execSync)('git status --porcelain', { encoding: 'utf-8' }).trim().length > 0;
             return {
@@ -930,7 +1011,7 @@ class TestLensReporter {
             // Check file size first
             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', '');
             // Step 1: Request pre-signed URL from server
             const presignedUrlEndpoint = `${baseUrl}/api/v1/artifacts/public/presigned-url`;
@@ -955,7 +1036,7 @@ class TestLensReporter {
             }
             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);
             // IMPORTANT: When using presigned URLs, we MUST include exactly the headers that were signed
             // The backend signs with ServerSideEncryption:'AES256', so we must send that header
@@ -973,7 +1054,7 @@ class TestLensReporter {
             if (uploadResponse.status !== 200) {
                 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`;
             const confirmBody = {
@@ -995,7 +1076,7 @@ class TestLensReporter {
             });
             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,
@@ -1014,29 +1095,29 @@ class TestLensReporter {
                 const errorData = error?.response?.data;
                 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;
                 }
             }
@@ -1054,9 +1135,9 @@ class TestLensReporter {
             else if (error.response?.status === 403) {
                 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
             return null;
@@ -1074,7 +1155,7 @@ class TestLensReporter {
             }
         }
         catch (error) {
-            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 = {
@@ -1093,31 +1174,15 @@ class TestLensReporter {
         };
         return contentTypes[ext] || 'application/octet-stream';
     }
-    generateS3Key(runId, testId, fileName) {
-        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}`;
-    }
-    sanitizeForS3(value) {
-        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
     getFileSize(filePath) {
         try {
             const stats = fs.statSync(filePath);
             return stats.size;
         }
         catch (error) {
-            console.warn(`Could not get file size for ${filePath}:`, error.message);
+            logger.warn(`Could not get file size for ${filePath}: ${error.message}`);
             return 0;
         }
     }