@browserbasehq/orca 3.0.9-alpha-4 → 3.1.0-headers

package/dist/cjs/tests/integration/logger-initialization.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/tests/integration/logger-initialization.spec.js

@@ -0,0 +1,597 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const logger_js_1 = require("../../lib/v3/logger.js");
+test_1.test.describe("V3 Logger Instance Routing", () => {
+    test_1.test.afterEach(() => {
+        // Clean up is handled by unbindInstanceLogger calls in tests
+    });
+    (0, test_1.test)("bindInstanceLogger routes logs to correct instance", () => {
+        const instanceId = "test-instance-001";
+        const capturedLogs = [];
+        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => {
+            capturedLogs.push(line);
+        });
+        try {
+            // Log within context
+            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Test message for instance",
+                    level: 1,
+                });
+            });
+            // Should have captured the log
+            (0, test_1.expect)(capturedLogs.length).toBe(1);
+            (0, test_1.expect)(capturedLogs[0].message).toBe("Test message for instance");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("unbindInstanceLogger stops routing", () => {
+        const instanceId = "test-instance-002";
+        const capturedLogs = [];
+        const consoleOutput = [];
+        const originalConsoleLog = console.log;
+        try {
+            console.log = (msg) => {
+                consoleOutput.push(msg);
+            };
+            (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => {
+                capturedLogs.push(line);
+            });
+            // Unbind immediately
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+            // Log - should fall back to console
+            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "After unbind",
+                    level: 1,
+                });
+            });
+            // Should not have captured via instance logger
+            (0, test_1.expect)(capturedLogs.length).toBe(0);
+            // But should have logged to console
+            (0, test_1.expect)(consoleOutput.length).toBeGreaterThan(0);
+        }
+        finally {
+            console.log = originalConsoleLog;
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("multiple instances have isolated log routing", () => {
+        const instance1Id = "test-instance-1";
+        const instance2Id = "test-instance-2";
+        const instance1Logs = [];
+        const instance2Logs = [];
+        (0, logger_js_1.bindInstanceLogger)(instance1Id, (line) => instance1Logs.push(line));
+        (0, logger_js_1.bindInstanceLogger)(instance2Id, (line) => instance2Logs.push(line));
+        try {
+            // Log from instance 1
+            (0, logger_js_1.withInstanceLogContext)(instance1Id, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "From instance 1",
+                    level: 1,
+                });
+            });
+            // Log from instance 2
+            (0, logger_js_1.withInstanceLogContext)(instance2Id, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "From instance 2",
+                    level: 1,
+                });
+            });
+            // Each instance should have only its own log
+            (0, test_1.expect)(instance1Logs.length).toBe(1);
+            (0, test_1.expect)(instance2Logs.length).toBe(1);
+            (0, test_1.expect)(instance1Logs[0].message).toBe("From instance 1");
+            (0, test_1.expect)(instance2Logs[0].message).toBe("From instance 2");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instance1Id);
+            (0, logger_js_1.unbindInstanceLogger)(instance2Id);
+        }
+    });
+    (0, test_1.test)("v3Logger falls back to console when no instance context", () => {
+        const capturedLogs = [];
+        const originalConsoleLog = console.log;
+        try {
+            console.log = (msg) => {
+                capturedLogs.push(msg);
+            };
+            // Log without any instance context
+            (0, logger_js_1.v3Logger)({
+                category: "test",
+                message: "Console fallback log",
+                level: 1,
+            });
+            // Should have used console logger
+            (0, test_1.expect)(capturedLogs.length).toBeGreaterThan(0);
+            const logOutput = capturedLogs.join("\n");
+            (0, test_1.expect)(logOutput).toContain("Console fallback log");
+        }
+        finally {
+            console.log = originalConsoleLog;
+        }
+    });
+    (0, test_1.test)("v3Logger falls back to console when instance logger throws", () => {
+        const instanceId = "failing-instance";
+        const capturedConsoleLogs = [];
+        const originalConsoleLog = console.log;
+        try {
+            console.log = (msg) => {
+                capturedConsoleLogs.push(msg);
+            };
+            // Bind a logger that throws
+            (0, logger_js_1.bindInstanceLogger)(instanceId, () => {
+                throw new Error("Instance logger failed");
+            });
+            // Should fall back to console without throwing
+            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                (0, test_1.expect)(() => {
+                    (0, logger_js_1.v3Logger)({
+                        category: "test",
+                        message: "Test with failing instance logger",
+                        level: 1,
+                    });
+                }).not.toThrow();
+            });
+            // Console should have received the log as fallback
+            (0, test_1.expect)(capturedConsoleLogs.length).toBeGreaterThan(0);
+            const logOutput = capturedConsoleLogs.join("\n");
+            (0, test_1.expect)(logOutput).toContain("Test with failing instance logger");
+        }
+        finally {
+            console.log = originalConsoleLog;
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("withInstanceLogContext nests properly", () => {
+        const outerInstanceId = "outer-instance";
+        const innerInstanceId = "inner-instance";
+        const outerLogs = [];
+        const innerLogs = [];
+        (0, logger_js_1.bindInstanceLogger)(outerInstanceId, (line) => outerLogs.push(line));
+        (0, logger_js_1.bindInstanceLogger)(innerInstanceId, (line) => innerLogs.push(line));
+        try {
+            (0, logger_js_1.withInstanceLogContext)(outerInstanceId, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Outer context",
+                    level: 1,
+                });
+                (0, logger_js_1.withInstanceLogContext)(innerInstanceId, () => {
+                    (0, logger_js_1.v3Logger)({
+                        category: "test",
+                        message: "Inner context",
+                        level: 1,
+                    });
+                });
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Back to outer context",
+                    level: 1,
+                });
+            });
+            // Outer instance should have 2 logs
+            (0, test_1.expect)(outerLogs.length).toBe(2);
+            (0, test_1.expect)(outerLogs[0].message).toBe("Outer context");
+            (0, test_1.expect)(outerLogs[1].message).toBe("Back to outer context");
+            // Inner instance should have 1 log
+            (0, test_1.expect)(innerLogs.length).toBe(1);
+            (0, test_1.expect)(innerLogs[0].message).toBe("Inner context");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(outerInstanceId);
+            (0, logger_js_1.unbindInstanceLogger)(innerInstanceId);
+        }
+    });
+    (0, test_1.test)("withInstanceLogContext returns function result", () => {
+        const instanceId = "return-test-instance";
+        (0, logger_js_1.bindInstanceLogger)(instanceId, () => { });
+        try {
+            const result = (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                return { success: true, value: 42 };
+            });
+            (0, test_1.expect)(result).toEqual({ success: true, value: 42 });
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("withInstanceLogContext works with async functions", async () => {
+        const instanceId = "async-test-instance";
+        const capturedLogs = [];
+        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => capturedLogs.push(line));
+        try {
+            const asyncResult = await (0, logger_js_1.withInstanceLogContext)(instanceId, async () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Log from async context",
+                    level: 1,
+                });
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Log after await",
+                    level: 1,
+                });
+                return "async result";
+            });
+            (0, test_1.expect)(asyncResult).toBe("async result");
+            (0, test_1.expect)(capturedLogs.length).toBe(2);
+            (0, test_1.expect)(capturedLogs[0].message).toBe("Log from async context");
+            (0, test_1.expect)(capturedLogs[1].message).toBe("Log after await");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("console fallback formats different log levels correctly", () => {
+        const consoleOutput = [];
+        const originalConsoleLog = console.log;
+        const originalConsoleError = console.error;
+        const originalConsoleDebug = console.debug;
+        try {
+            console.log = (msg) => {
+                consoleOutput.push({ level: "log", msg });
+            };
+            console.error = (msg) => {
+                consoleOutput.push({ level: "error", msg });
+            };
+            console.debug = (msg) => {
+                consoleOutput.push({ level: "debug", msg });
+            };
+            // Test error level (0)
+            (0, logger_js_1.v3Logger)({
+                category: "test",
+                message: "Error message",
+                level: 0,
+            });
+            // Test info level (1)
+            (0, logger_js_1.v3Logger)({
+                category: "test",
+                message: "Info message",
+                level: 1,
+            });
+            // Test debug level (2)
+            (0, logger_js_1.v3Logger)({
+                category: "test",
+                message: "Debug message",
+                level: 2,
+            });
+            (0, test_1.expect)(consoleOutput.length).toBe(3);
+            (0, test_1.expect)(consoleOutput[0].level).toBe("error");
+            (0, test_1.expect)(consoleOutput[0].msg).toContain("ERROR");
+            (0, test_1.expect)(consoleOutput[0].msg).toContain("Error message");
+            (0, test_1.expect)(consoleOutput[1].level).toBe("log");
+            (0, test_1.expect)(consoleOutput[1].msg).toContain("INFO");
+            (0, test_1.expect)(consoleOutput[1].msg).toContain("Info message");
+            (0, test_1.expect)(consoleOutput[2].level).toBe("debug");
+            (0, test_1.expect)(consoleOutput[2].msg).toContain("DEBUG");
+            (0, test_1.expect)(consoleOutput[2].msg).toContain("Debug message");
+        }
+        finally {
+            console.log = originalConsoleLog;
+            console.error = originalConsoleError;
+            console.debug = originalConsoleDebug;
+        }
+    });
+    (0, test_1.test)("console fallback formats auxiliary data", () => {
+        const consoleOutput = [];
+        const originalConsoleLog = console.log;
+        try {
+            console.log = (msg) => {
+                consoleOutput.push(msg);
+            };
+            (0, logger_js_1.v3Logger)({
+                category: "test",
+                message: "Message with auxiliary",
+                level: 1,
+                auxiliary: {
+                    stringValue: { value: "test", type: "string" },
+                    integerValue: { value: "42", type: "integer" },
+                    objectValue: {
+                        value: JSON.stringify({ nested: "data" }),
+                        type: "object",
+                    },
+                },
+            });
+            (0, test_1.expect)(consoleOutput.length).toBe(1);
+            const output = consoleOutput[0];
+            (0, test_1.expect)(output).toContain("Message with auxiliary");
+            (0, test_1.expect)(output).toContain("stringValue");
+            (0, test_1.expect)(output).toContain("integerValue");
+            (0, test_1.expect)(output).toContain("objectValue");
+        }
+        finally {
+            console.log = originalConsoleLog;
+        }
+    });
+    (0, test_1.test)("concurrent instances don't interfere", () => {
+        const instances = Array.from({ length: 10 }, (_, i) => `instance-${i}`);
+        const logsByInstance = new Map();
+        // Bind all instances
+        instances.forEach((id) => {
+            const logs = [];
+            logsByInstance.set(id, logs);
+            (0, logger_js_1.bindInstanceLogger)(id, (line) => logs.push(line));
+        });
+        try {
+            // Log from each instance
+            instances.forEach((id, index) => {
+                (0, logger_js_1.withInstanceLogContext)(id, () => {
+                    (0, logger_js_1.v3Logger)({
+                        category: "test",
+                        message: `Message from ${id}`,
+                        level: 1,
+                        auxiliary: {
+                            index: { value: String(index), type: "integer" },
+                        },
+                    });
+                });
+            });
+            // Verify each instance received only its own log
+            instances.forEach((id) => {
+                const logs = logsByInstance.get(id);
+                (0, test_1.expect)(logs.length).toBe(1);
+                (0, test_1.expect)(logs[0].message).toBe(`Message from ${id}`);
+            });
+        }
+        finally {
+            instances.forEach((id) => (0, logger_js_1.unbindInstanceLogger)(id));
+        }
+    });
+});
+test_1.test.describe("V3 Logger with External Logger (Production Pattern)", () => {
+    test_1.test.afterEach(() => {
+        // Clean up instance loggers
+    });
+    (0, test_1.test)("external logger receives all logs from v3Logger", () => {
+        const instanceId = "v3-instance-with-external";
+        const externalLogs = [];
+        // Simulate V3 constructor behavior with external logger
+        const externalLogger = (line) => {
+            externalLogs.push(line);
+        };
+        (0, logger_js_1.bindInstanceLogger)(instanceId, externalLogger);
+        try {
+            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "a11y/snapshot",
+                    message: "Capturing hybrid snapshot",
+                    level: 0,
+                });
+                (0, logger_js_1.v3Logger)({
+                    category: "handlers/act",
+                    message: "Executing action",
+                    level: 1,
+                    auxiliary: {
+                        action: { value: "click", type: "string" },
+                    },
+                });
+                (0, logger_js_1.v3Logger)({
+                    category: "debug",
+                    message: "Debug details",
+                    level: 2,
+                });
+            });
+            // All logs should be captured by external logger
+            (0, test_1.expect)(externalLogs.length).toBe(3);
+            (0, test_1.expect)(externalLogs[0].message).toBe("Capturing hybrid snapshot");
+            (0, test_1.expect)(externalLogs[1].message).toBe("Executing action");
+            (0, test_1.expect)(externalLogs[2].message).toBe("Debug details");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("StagehandLogger wrapper forwards to external logger", () => {
+        const instanceId = "v3-with-stagehand-wrapper";
+        const externalLogs = [];
+        // Simulate V3's stagehandLogger.log() wrapping pattern
+        const mockStagehandLogger = {
+            log: (line) => {
+                // This simulates StagehandLogger.log() which internally calls externalLogger
+                externalLogs.push(line);
+            },
+        };
+        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => mockStagehandLogger.log(line));
+        try {
+            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Log through StagehandLogger wrapper",
+                    level: 1,
+                });
+            });
+            (0, test_1.expect)(externalLogs.length).toBe(1);
+            (0, test_1.expect)(externalLogs[0].message).toBe("Log through StagehandLogger wrapper");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("multiple V3 instances with different external loggers", () => {
+        const instance1Id = "v3-instance-1";
+        const instance2Id = "v3-instance-2";
+        const external1Logs = [];
+        const external2Logs = [];
+        // Simulate two V3 instances with different external loggers
+        (0, logger_js_1.bindInstanceLogger)(instance1Id, (line) => external1Logs.push(line));
+        (0, logger_js_1.bindInstanceLogger)(instance2Id, (line) => external2Logs.push(line));
+        try {
+            // Instance 1 logs
+            (0, logger_js_1.withInstanceLogContext)(instance1Id, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "instance1",
+                    message: "Instance 1 activity",
+                    level: 1,
+                });
+            });
+            // Instance 2 logs
+            (0, logger_js_1.withInstanceLogContext)(instance2Id, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "instance2",
+                    message: "Instance 2 activity",
+                    level: 1,
+                });
+            });
+            // Each external logger should only have its instance's logs
+            (0, test_1.expect)(external1Logs.length).toBe(1);
+            (0, test_1.expect)(external2Logs.length).toBe(1);
+            (0, test_1.expect)(external1Logs[0].message).toBe("Instance 1 activity");
+            (0, test_1.expect)(external2Logs[0].message).toBe("Instance 2 activity");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instance1Id);
+            (0, logger_js_1.unbindInstanceLogger)(instance2Id);
+        }
+    });
+    (0, test_1.test)("external logger receives logs with auxiliary data preserved", () => {
+        const instanceId = "v3-with-auxiliary";
+        const externalLogs = [];
+        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => externalLogs.push(line));
+        try {
+            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "extract",
+                    message: "Extracting data",
+                    level: 1,
+                    auxiliary: {
+                        selector: { value: "xpath=/html/body", type: "string" },
+                        timeout: { value: "5000", type: "integer" },
+                        retries: { value: "3", type: "integer" },
+                        metadata: {
+                            value: JSON.stringify({ key: "value" }),
+                            type: "object",
+                        },
+                    },
+                });
+            });
+            (0, test_1.expect)(externalLogs.length).toBe(1);
+            const log = externalLogs[0];
+            (0, test_1.expect)(log.auxiliary).toBeDefined();
+            (0, test_1.expect)(log.auxiliary?.selector?.value).toBe("xpath=/html/body");
+            (0, test_1.expect)(log.auxiliary?.timeout?.value).toBe("5000");
+            (0, test_1.expect)(log.auxiliary?.retries?.value).toBe("3");
+            (0, test_1.expect)(log.auxiliary?.metadata?.type).toBe("object");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("external logger handles rapid concurrent logs", () => {
+        const instanceId = "v3-rapid-logs";
+        const externalLogs = [];
+        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => externalLogs.push(line));
+        try {
+            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                // Simulate rapid logging like during snapshot capture
+                for (let i = 0; i < 50; i++) {
+                    (0, logger_js_1.v3Logger)({
+                        category: "perf",
+                        message: `Operation ${i}`,
+                        level: 2,
+                        auxiliary: {
+                            iteration: { value: String(i), type: "integer" },
+                        },
+                    });
+                }
+            });
+            // All logs should be captured
+            (0, test_1.expect)(externalLogs.length).toBe(50);
+            (0, test_1.expect)(externalLogs[0].message).toBe("Operation 0");
+            (0, test_1.expect)(externalLogs[49].message).toBe("Operation 49");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("external logger can filter by log level", () => {
+        const instanceId = "v3-with-filtering";
+        const errorLogs = [];
+        // External logger that only captures errors
+        const filteringLogger = (line) => {
+            if (line.level === 0) {
+                errorLogs.push(line);
+            }
+        };
+        (0, logger_js_1.bindInstanceLogger)(instanceId, filteringLogger);
+        try {
+            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Info message",
+                    level: 1,
+                });
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Error message",
+                    level: 0,
+                });
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Debug message",
+                    level: 2,
+                });
+                (0, logger_js_1.v3Logger)({
+                    category: "test",
+                    message: "Another error",
+                    level: 0,
+                });
+            });
+            // Only error logs should be captured
+            (0, test_1.expect)(errorLogs.length).toBe(2);
+            (0, test_1.expect)(errorLogs[0].message).toBe("Error message");
+            (0, test_1.expect)(errorLogs[1].message).toBe("Another error");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+    (0, test_1.test)("external logger persists across async operations", async () => {
+        const instanceId = "v3-async-ops";
+        const externalLogs = [];
+        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => externalLogs.push(line));
+        try {
+            await (0, logger_js_1.withInstanceLogContext)(instanceId, async () => {
+                (0, logger_js_1.v3Logger)({
+                    category: "async",
+                    message: "Before async operation",
+                    level: 1,
+                });
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                (0, logger_js_1.v3Logger)({
+                    category: "async",
+                    message: "After async operation",
+                    level: 1,
+                });
+                await Promise.all([
+                    Promise.resolve().then(() => (0, logger_js_1.v3Logger)({
+                        category: "async",
+                        message: "Parallel operation 1",
+                        level: 1,
+                    })),
+                    Promise.resolve().then(() => (0, logger_js_1.v3Logger)({
+                        category: "async",
+                        message: "Parallel operation 2",
+                        level: 1,
+                    })),
+                ]);
+            });
+            // All logs should be captured despite async boundaries
+            (0, test_1.expect)(externalLogs.length).toBe(4);
+            (0, test_1.expect)(externalLogs[0].message).toBe("Before async operation");
+            (0, test_1.expect)(externalLogs[1].message).toBe("After async operation");
+        }
+        finally {
+            (0, logger_js_1.unbindInstanceLogger)(instanceId);
+        }
+    });
+});
+//# sourceMappingURL=logger-initialization.spec.js.map