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

package/src/logging/ToolLogger.test.ts

@@ -0,0 +1,1020 @@
+import { ToolLogger } from './ToolLogger';
+import { logger, LogVisibility } from '@zaiusinc/app-sdk';
+import * as App from '@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 = logger as jest.Mocked<typeof logger>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // Helper function to check JSON string logs
+  const expectJsonLog = (expectedData: any) => {
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      LogVisibility.Zaius,
+      JSON.stringify(expectedData)
+    );
+  };
+
+  const createMockRequest = (overrides: any = {}): App.Request => {
+    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: any = {}, headers: any = {}): App.Response => {
+    const mockHeaders = {
+      get: jest.fn().mockImplementation((name: string) => {
+        if (name === 'content-type') return 'application/json';
+        return headers[name] || null;
+      })
+    };
+
+    const response = {
+      status,
+      headers: mockHeaders,
+      _bodyJSON: bodyJSON
+    } as any;
+
+    // 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: number,
+    bodyData: Uint8Array | undefined,
+    contentType: string
+  ): App.Response => {
+    const mockHeaders = {
+      get: jest.fn().mockReturnValue(contentType)
+    };
+
+    const response = {
+      status,
+      headers: mockHeaders
+    } as any;
+
+    Object.defineProperty(response, 'bodyAsU8Array', {
+      get() {
+        return bodyData;
+      },
+      enumerable: true
+    });
+
+    return response;
+  };
+
+  describe('logRequest', () => {
+    it('should log request with parameters', () => {
+      const req = createMockRequest();
+
+      ToolLogger.logRequest(req);
+
+      const expectedLog = {
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        method: 'POST',
+        parameters: {
+          name: 'test',
+          value: 'data'
+        }
+      };
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        LogVisibility.Zaius,
+        JSON.stringify(expectedLog)
+      );
+    });
+
+    it('should handle request without parameters', () => {
+      const req = createMockRequest({
+        bodyJSON: null
+      });
+
+      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.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.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.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.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.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.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.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.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.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: any = { 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.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.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.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.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(
+        LogVisibility.Zaius,
+        JSON.stringify(expectedLog)
+      );
+    });
+
+    it('should log error response', () => {
+      const req = createMockRequest();
+      const response = createMockResponse(400, { error: 'Bad request' });
+
+      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.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.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.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
+      } as any;
+
+      // Create a getter that throws when accessed (simulating serialization error)
+      Object.defineProperty(response, 'bodyAsU8Array', {
+        get() {
+          throw new Error('Circular structure');
+        },
+        enumerable: true
+      });
+
+      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.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.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.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.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.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.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.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.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.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.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.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.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.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.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)'
+              ]
+            }
+          ]
+        }
+      });
+    });
+  });
+});