@optimizely-opal/opal-tool-ocp-sdk 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/logging/ToolLogger.test.js

@@ -0,0 +1,864 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ToolLogger_1 = require("./ToolLogger");
+const app_sdk_1 = require("@zaiusinc/app-sdk");
+// Mock the logger
+jest.mock('@zaiusinc/app-sdk', () => ({
+    logger: {
+        info: jest.fn()
+    },
+    LogVisibility: {
+        Zaius: 'zaius'
+    },
+    Headers: jest.fn(),
+    Response: jest.fn()
+}));
+describe('ToolLogger', () => {
+    const mockLogger = app_sdk_1.logger;
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    // Helper function to check JSON string logs
+    const expectJsonLog = (expectedData) => {
+        expect(mockLogger.info).toHaveBeenCalledWith(app_sdk_1.LogVisibility.Zaius, JSON.stringify(expectedData));
+    };
+    const createMockRequest = (overrides = {}) => {
+        const defaultRequest = {
+            path: '/test-tool',
+            method: 'POST',
+            bodyJSON: {
+                parameters: {
+                    name: 'test',
+                    value: 'data'
+                }
+            },
+            headers: {
+                get: jest.fn().mockReturnValue('application/json')
+            }
+        };
+        return { ...defaultRequest, ...overrides };
+    };
+    const createMockResponse = (status = 200, bodyJSON = {}, headers = {}) => {
+        const mockHeaders = {
+            get: jest.fn().mockImplementation((name) => {
+                if (name === 'content-type')
+                    return 'application/json';
+                return headers[name] || null;
+            })
+        };
+        const response = {
+            status,
+            headers: mockHeaders,
+            _bodyJSON: bodyJSON
+        };
+        // Add getter for bodyJSON that returns the stored value
+        Object.defineProperty(response, 'bodyJSON', {
+            get() {
+                return this._bodyJSON;
+            },
+            set(value) {
+                this._bodyJSON = value;
+            },
+            enumerable: true
+        });
+        // Add getter for bodyAsU8Array that recalculates based on current bodyJSON
+        Object.defineProperty(response, 'bodyAsU8Array', {
+            get() {
+                if (this._bodyJSON !== null && this._bodyJSON !== undefined) {
+                    // This will throw for circular references, which matches real behavior
+                    const jsonString = JSON.stringify(this._bodyJSON);
+                    return new Uint8Array(Buffer.from(jsonString));
+                }
+                return undefined;
+            },
+            enumerable: true
+        });
+        return response;
+    };
+    const createMockResponseWithBody = (status, bodyData, contentType) => {
+        const mockHeaders = {
+            get: jest.fn().mockReturnValue(contentType)
+        };
+        const response = {
+            status,
+            headers: mockHeaders
+        };
+        Object.defineProperty(response, 'bodyAsU8Array', {
+            get() {
+                return bodyData;
+            },
+            enumerable: true
+        });
+        return response;
+    };
+    describe('logRequest', () => {
+        it('should log request with parameters', () => {
+            const req = createMockRequest();
+            ToolLogger_1.ToolLogger.logRequest(req);
+            const expectedLog = {
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    name: 'test',
+                    value: 'data'
+                }
+            };
+            expect(mockLogger.info).toHaveBeenCalledWith(app_sdk_1.LogVisibility.Zaius, JSON.stringify(expectedLog));
+        });
+        it('should handle request without parameters', () => {
+            const req = createMockRequest({
+                bodyJSON: null
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: null
+            });
+        });
+        it('should use bodyJSON as parameters when no parameters field exists', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    name: 'direct',
+                    action: 'test'
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    name: 'direct',
+                    action: 'test'
+                }
+            });
+        });
+        it('should redact all sensitive field variations', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        username: 'john',
+                        password: 'secret123',
+                        api_key: 'key123',
+                        secret: 'mysecret',
+                        token: 'abc123',
+                        auth: 'authdata',
+                        credentials: 'creds',
+                        access_token: 'access123',
+                        refresh_token: 'refresh123',
+                        private_key: 'privatekey',
+                        client_secret: 'clientsecret',
+                        normal_field: 'visible'
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    username: 'john',
+                    password: '[REDACTED]',
+                    api_key: '[REDACTED]',
+                    secret: '[REDACTED]',
+                    token: '[REDACTED]',
+                    auth: '[REDACTED]',
+                    credentials: '[REDACTED]',
+                    access_token: '[REDACTED]',
+                    refresh_token: '[REDACTED]',
+                    private_key: '[REDACTED]',
+                    client_secret: '[REDACTED]',
+                    normal_field: 'visible'
+                }
+            });
+        });
+        it('should redact sensitive fields with case variations', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        PASSWORD: 'secret1',
+                        API_KEY: 'secret2',
+                        clientSecret: 'secret3',
+                        user_password: 'secret4',
+                        oauth_token: 'secret5',
+                        ssh_key: 'secret6',
+                        normal_field: 'visible'
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    PASSWORD: '[REDACTED]',
+                    API_KEY: '[REDACTED]',
+                    clientSecret: '[REDACTED]',
+                    user_password: '[REDACTED]',
+                    oauth_token: '[REDACTED]',
+                    ssh_key: '[REDACTED]',
+                    normal_field: 'visible'
+                }
+            });
+        });
+        it('should truncate long string values', () => {
+            const longString = 'a'.repeat(150);
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        description: longString,
+                        short_field: 'normal'
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    description: `${'a'.repeat(118)}...[22 truncated]...${'a'.repeat(10)}`,
+                    short_field: 'normal'
+                }
+            });
+        });
+        it('should truncate large arrays', () => {
+            const largeArray = Array.from({ length: 15 }, (_, i) => `item${i}`);
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        items: largeArray,
+                        small_array: ['a', 'b']
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    items: [
+                        ...largeArray.slice(0, 2),
+                        '... (13 more items truncated)'
+                    ],
+                    small_array: ['a', 'b']
+                }
+            });
+        });
+        it('should handle nested objects with sensitive fields', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        user: {
+                            name: 'John',
+                            email: 'john@example.com',
+                            password: 'secret123'
+                        },
+                        config: {
+                            database: {
+                                host: 'localhost',
+                                port: 5432,
+                                password: 'dbpass'
+                            },
+                            api_key: 'apikey123'
+                        }
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    user: {
+                        name: 'John',
+                        email: '[REDACTED]',
+                        password: '[REDACTED]'
+                    },
+                    config: {
+                        database: {
+                            host: 'localhost',
+                            port: 5432,
+                            password: '[REDACTED]'
+                        },
+                        api_key: '[REDACTED]'
+                    }
+                }
+            });
+        });
+        it('should handle null and undefined values', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        nullValue: null,
+                        undefinedValue: undefined,
+                        emptyString: '',
+                        zero: 0,
+                        false: false,
+                        password: null // sensitive field with null value
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    nullValue: null,
+                    emptyString: '',
+                    zero: 0,
+                    false: false,
+                    password: '[REDACTED]'
+                }
+            });
+        });
+        it('should handle arrays in sensitive fields', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        credentials: ['user', 'pass', 'token'],
+                        public_list: ['item1', 'item2']
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    credentials: '[REDACTED]',
+                    public_list: ['item1', 'item2']
+                }
+            });
+        });
+        it('should handle objects in sensitive fields', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        auth: {
+                            username: 'john',
+                            password: 'secret'
+                        },
+                        public_config: {
+                            timeout: 30,
+                            retries: 3
+                        }
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    auth: '[REDACTED]',
+                    public_config: {
+                        timeout: 30,
+                        retries: 3
+                    }
+                }
+            });
+        });
+        it('should respect max depth to prevent infinite recursion', () => {
+            const deepObject = { level: 0, data: 'test' };
+            let current = deepObject;
+            // Create a very deep nested object (deeper than maxDepth)
+            for (let i = 1; i <= 10; i++) {
+                current.nested = { level: i, data: `level${i}` };
+                current = current.nested;
+            }
+            const req = createMockRequest({
+                bodyJSON: { parameters: { deep: deepObject } }
+            });
+            // Should not throw error or cause infinite recursion
+            expect(() => ToolLogger_1.ToolLogger.logRequest(req)).not.toThrow();
+            expect(mockLogger.info).toHaveBeenCalled();
+            // Verify that deeply nested parts are replaced with placeholder
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            // Navigate to a deeply nested level that should be truncated
+            // At maxDepth=5, objects beyond depth 5 should be replaced
+            const nested1 = loggedData.parameters.deep.nested;
+            expect(nested1).toBeDefined(); // depth 2
+            const nested2 = nested1.nested;
+            expect(nested2).toBeDefined(); // depth 3
+            const nested3 = nested2.nested;
+            expect(nested3).toBeDefined(); // depth 4
+            const nested4 = nested3.nested;
+            expect(nested4).toBe('[MAX_DEPTH_EXCEEDED]'); // depth 5, should be truncated
+        });
+        it('should replace deeply nested objects with MAX_DEPTH_EXCEEDED placeholder', () => {
+            // Create an object with exactly 6 levels (exceeds maxDepth of 5)
+            const deepObject = {
+                level1: {
+                    level2: {
+                        level3: {
+                            level4: {
+                                level5: {
+                                    level6: {
+                                        password: 'should-not-be-visible',
+                                        credit_card: '1234-5678-9012-3456',
+                                        data: 'sensitive-info'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+            const req = createMockRequest({
+                bodyJSON: { parameters: { deep: deepObject } }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            // Verify that the deeply nested object is replaced with placeholder
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            // Navigate to the deeply nested part that should be replaced
+            // At maxDepth=5, the 5th level (level4) gets replaced with the placeholder
+            const level4 = loggedData.parameters.deep.level1.level2.level3.level4;
+            expect(level4).toBe('[MAX_DEPTH_EXCEEDED]');
+        });
+        it('should handle arrays containing deeply nested objects that exceed max depth', () => {
+            // Create a structure where the array is shallow enough to be processed (depth 3),
+            // but individual objects within the array exceed the max depth
+            const arrayWithDeepObjects = {
+                level1: {
+                    items: [
+                        {
+                            shallow: 'data',
+                            level2: {
+                                level3: {
+                                    level4: {
+                                        level5: {
+                                            password: 'secret-in-deep-array-object',
+                                            credit_card: '1234-5678-9012-3456'
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        'simple-item',
+                        {
+                            shallow: 'data'
+                        },
+                        {
+                            level2: {
+                                level3: {
+                                    level4: {
+                                        another: 'deep-object'
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                }
+            };
+            const req = createMockRequest({
+                bodyJSON: { parameters: arrayWithDeepObjects }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            // Verify the array structure and depth handling
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            const items = loggedData.parameters.level1.items;
+            expect(items.length).toBe(3);
+            // First item: deeply nested object with inner parts replaced by placeholder
+            // shallow object should be processed normally
+            expect(items[0]).toEqual({
+                shallow: 'data',
+                level2: {
+                    level3: {
+                        level4: '[MAX_DEPTH_EXCEEDED]'
+                    }
+                }
+            });
+            // Second item: simple string should remain unchanged
+            expect(items[1]).toBe('simple-item');
+        });
+    });
+    describe('logResponse', () => {
+        it('should log successful response with all details', () => {
+            const req = createMockRequest();
+            const response = createMockResponse(200, { result: 'success', data: 'test' });
+            ToolLogger_1.ToolLogger.logResponse(req, response, 150);
+            const expectedLog = {
+                event: 'opal_tool_response',
+                path: '/test-tool',
+                duration: '150ms',
+                status: 200,
+                contentType: 'application/json',
+                contentLength: 34, // JSON.stringify({ result: 'success', data: 'test' }).length
+                success: true,
+                responseBody: { result: 'success', data: 'test' }
+            };
+            expect(mockLogger.info).toHaveBeenCalledWith(app_sdk_1.LogVisibility.Zaius, JSON.stringify(expectedLog));
+        });
+        it('should log error response', () => {
+            const req = createMockRequest();
+            const response = createMockResponse(400, { error: 'Bad request' });
+            ToolLogger_1.ToolLogger.logResponse(req, response, 75);
+            expectJsonLog({
+                event: 'opal_tool_response',
+                path: '/test-tool',
+                duration: '75ms',
+                status: 400,
+                contentType: 'application/json',
+                contentLength: 23,
+                success: false,
+                responseBody: { error: 'Bad request' }
+            });
+        });
+        it('should handle response without body data', () => {
+            const req = createMockRequest();
+            const response = createMockResponseWithBody(204, undefined, 'application/json');
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            expectJsonLog({
+                event: 'opal_tool_response',
+                path: '/test-tool',
+                status: 204,
+                contentType: 'application/json',
+                contentLength: 'unknown',
+                success: true
+            });
+        });
+        it('should handle response without processing time', () => {
+            const req = createMockRequest();
+            const response = createMockResponse(200, { data: 'test' });
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            expectJsonLog({
+                event: 'opal_tool_response',
+                path: '/test-tool',
+                status: 200,
+                contentType: 'application/json',
+                contentLength: 15,
+                success: true,
+                responseBody: { data: 'test' }
+            });
+        });
+        it('should handle unknown content type - response body not logged', () => {
+            const req = createMockRequest();
+            const response = createMockResponse(200, { data: 'test' });
+            response.headers.get = jest.fn().mockReturnValue(null);
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            expectJsonLog({
+                event: 'opal_tool_response',
+                path: '/test-tool',
+                status: 200,
+                contentType: 'unknown',
+                contentLength: 15,
+                success: true
+            });
+        });
+        it('should handle content length calculation error', () => {
+            const req = createMockRequest();
+            // Simulate a response that will cause errors when trying to calculate content length
+            // by providing a Uint8Array but the underlying data causes issues
+            const mockHeaders = {
+                get: jest.fn().mockReturnValue('application/json')
+            };
+            const response = {
+                status: 200,
+                headers: mockHeaders
+            };
+            // Create a getter that throws when accessed (simulating serialization error)
+            Object.defineProperty(response, 'bodyAsU8Array', {
+                get() {
+                    throw new Error('Circular structure');
+                },
+                enumerable: true
+            });
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            // The error causes both contentLength and responseBody to fail gracefully
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            expect(loggedData.event).toBe('opal_tool_response');
+            expect(loggedData.contentLength).toBe('unknown');
+            expect(loggedData.responseBody).toBeUndefined();
+        });
+        it('should correctly identify success status codes', () => {
+            const req = createMockRequest();
+            const testCases = [
+                { status: 200, expected: true },
+                { status: 201, expected: true },
+                { status: 204, expected: true },
+                { status: 299, expected: true },
+                { status: 300, expected: false },
+                { status: 400, expected: false },
+                { status: 404, expected: false },
+                { status: 500, expected: false }
+            ];
+            testCases.forEach(({ status, expected }) => {
+                mockLogger.info.mockClear();
+                const response = createMockResponse(status);
+                ToolLogger_1.ToolLogger.logResponse(req, response);
+                const logCall = mockLogger.info.mock.calls[0];
+                const loggedData = JSON.parse(logCall[1]);
+                expect(loggedData.event).toBe('opal_tool_response');
+                expect(loggedData.path).toBe('/test-tool');
+                expect(loggedData.status).toBe(status);
+                expect(loggedData.contentType).toBe('application/json');
+                expect(loggedData.contentLength).toBe(2);
+                expect(loggedData.success).toBe(expected);
+                expect(loggedData.responseBody).toEqual({});
+            });
+        });
+        it('should handle different content types', () => {
+            const req = createMockRequest();
+            const testCases = [
+                { contentType: 'application/json', expectedBody: { data: 'test' } },
+                { contentType: 'text/plain', expectedBody: '{"data":"test"}' },
+                { contentType: 'text/html', expectedBody: '{"data":"test"}' }
+            ];
+            testCases.forEach(({ contentType, expectedBody }) => {
+                mockLogger.info.mockClear();
+                const response = createMockResponse(200, { data: 'test' });
+                response.headers.get = jest.fn().mockReturnValue(contentType);
+                ToolLogger_1.ToolLogger.logResponse(req, response);
+                const logCall = mockLogger.info.mock.calls[0];
+                const loggedData = JSON.parse(logCall[1]);
+                expect(loggedData.event).toBe('opal_tool_response');
+                expect(loggedData.path).toBe('/test-tool');
+                expect(loggedData.status).toBe(200);
+                expect(loggedData.contentType).toBe(contentType);
+                expect(loggedData.contentLength).toBe(15);
+                expect(loggedData.success).toBe(true);
+                expect(loggedData.responseBody).toEqual(expectedBody);
+            });
+        });
+        it('should log short successful response body', () => {
+            const req = createMockRequest();
+            const response = createMockResponse(200, { result: 'success', data: 'test' });
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            expect(loggedData.responseBody).toEqual({ result: 'success', data: 'test' });
+            expect(loggedData.success).toBe(true);
+        });
+        it('should truncate long successful response body to 256 chars', () => {
+            const req = createMockRequest();
+            const longData = 'a'.repeat(300);
+            const response = createMockResponse(200, { message: longData });
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            // The response body should be truncated when stringified
+            expect(loggedData.responseBody.message).toContain(' truncated]...');
+        });
+        it('truncates long properties of failed responses', () => {
+            const req = createMockRequest();
+            const longData = 'a'.repeat(150);
+            const response = createMockResponse(400, { error: 'Bad request', details: longData });
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            // Failed responses should include full body, not truncated
+            expect(loggedData.responseBody.error).toEqual('Bad request');
+            expect(loggedData.responseBody.details).toContain(' truncated]...');
+            expect(loggedData.success).toBe(false);
+        });
+        it('should redact sensitive data in response body', () => {
+            const req = createMockRequest();
+            const response = createMockResponse(200, {
+                user: 'john',
+                password: 'secret123',
+                api_key: 'key456',
+                data: 'public'
+            });
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            expect(loggedData.responseBody).toEqual({
+                user: 'john',
+                password: '[REDACTED]',
+                api_key: '[REDACTED]',
+                data: 'public'
+            });
+        });
+        it('should handle response with no body', () => {
+            const req = createMockRequest();
+            const response = createMockResponseWithBody(204, undefined, 'application/json');
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            expect(loggedData.responseBody).toBeUndefined();
+            expect(loggedData.success).toBe(true);
+        });
+        it('should handle plain text response body', () => {
+            const req = createMockRequest();
+            const plainText = 'This is a plain text response';
+            const response = createMockResponseWithBody(200, new Uint8Array(Buffer.from(plainText)), 'text/plain');
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            expect(loggedData.responseBody).toBe(plainText);
+        });
+        it('should truncate long plain text successful responses', () => {
+            const req = createMockRequest();
+            const longText = 'a'.repeat(300);
+            const response = createMockResponseWithBody(200, new Uint8Array(Buffer.from(longText)), 'text/plain');
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            expect(loggedData.responseBody).toBe(`${'a'.repeat(256)}... (truncated)`);
+        });
+        it('should not truncate long plain text failed responses', () => {
+            const req = createMockRequest();
+            const longText = 'a'.repeat(150);
+            const response = createMockResponseWithBody(500, new Uint8Array(Buffer.from(longText)), 'text/plain');
+            ToolLogger_1.ToolLogger.logResponse(req, response);
+            const logCall = mockLogger.info.mock.calls[0];
+            const loggedData = JSON.parse(logCall[1]);
+            expect(loggedData.responseBody).toBe(longText);
+            expect(loggedData.success).toBe(false);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle empty request bodyJSON', () => {
+            const req = createMockRequest({
+                bodyJSON: {}
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {}
+            });
+        });
+        it('should handle request with only parameters field', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        field: 'value' // Changed from 'key' to 'field' to avoid sensitive field detection
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    field: 'value'
+                }
+            });
+        });
+        it('should handle mixed data types in parameters', () => {
+            const req = createMockRequest({
+                bodyJSON: {
+                    parameters: {
+                        string: 'text',
+                        number: 42,
+                        boolean: true,
+                        array: [1, 2],
+                        object: { nested: 'value' },
+                        nullValue: null,
+                        password: 'secret'
+                    }
+                }
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/test-tool',
+                method: 'POST',
+                parameters: {
+                    string: 'text',
+                    number: 42,
+                    boolean: true,
+                    array: [1, 2],
+                    object: { nested: 'value' },
+                    nullValue: null,
+                    password: '[REDACTED]'
+                }
+            });
+        });
+        it('should handle tool override request with enhanced parameter descriptions', () => {
+            const overrideRequest = {
+                tools: [
+                    {
+                        name: 'calculate_experiment_runtime',
+                        description: 'OVERRIDDEN: Enhanced experiment runtime calculator with advanced features',
+                        parameters: [
+                            {
+                                name: 'BCR',
+                                type: 'number',
+                                description: 'OVERRIDDEN: Enhanced baseline conversion rate with validation',
+                                required: true
+                            },
+                            {
+                                name: 'MDE',
+                                type: 'number',
+                                description: 'OVERRIDDEN: Enhanced minimum detectable effect calculation',
+                                required: true
+                            },
+                            {
+                                name: 'sigLevel',
+                                type: 'number',
+                                description: 'OVERRIDDEN: Enhanced statistical significance level',
+                                required: true
+                            },
+                            {
+                                name: 'numVariations',
+                                type: 'number',
+                                description: 'OVERRIDDEN: Enhanced number of variations handling',
+                                required: true
+                            },
+                            {
+                                name: 'dailyVisitors',
+                                type: 'number',
+                                description: 'OVERRIDDEN: Enhanced daily visitor count with forecasting',
+                                required: true
+                            }
+                        ]
+                    }
+                    // Note: NOT including calculate_sample_size in override
+                ]
+            };
+            const req = createMockRequest({
+                path: '/overrides',
+                bodyJSON: overrideRequest
+            });
+            ToolLogger_1.ToolLogger.logRequest(req);
+            expectJsonLog({
+                event: 'opal_tool_request',
+                path: '/overrides',
+                method: 'POST',
+                parameters: {
+                    tools: [
+                        {
+                            name: 'calculate_experiment_runtime',
+                            description: 'OVERRIDDEN: Enhanced experiment runtime calculator with advanced features',
+                            parameters: [
+                                {
+                                    name: 'BCR',
+                                    type: 'number',
+                                    description: 'OVERRIDDEN: Enhanced baseline conversion rate with validation',
+                                    required: true
+                                },
+                                {
+                                    name: 'MDE',
+                                    type: 'number',
+                                    description: 'OVERRIDDEN: Enhanced minimum detectable effect calculation',
+                                    required: true
+                                },
+                                '... (3 more items truncated)'
+                            ]
+                        }
+                    ]
+                }
+            });
+        });
+    });
+});
+//# sourceMappingURL=ToolLogger.test.js.map