stateful logging

tests/logger.test.ts

@@ -42,4 +42,23 @@ describe('Pino logger', () => {
         expect(entry.answer).toBe(42)
         expect(entry.msg).toBe('warning')
     })
+
+    it('preserves parent context when adding command bindings', () => {
+        output = ''
+        const eventLogger = createLogger({
+            component: 'event',
+            event: 'InteractionCreate'
+        }, parentLogger)
+        const commandLogger = createLogger({
+            component: 'command',
+            command: 'summary'
+        }, eventLogger)
+
+        commandLogger.info('command started')
+
+        const entry = JSON.parse(output)
+        expect(entry.component).toBe('command')
+        expect(entry.event).toBe('InteractionCreate')
+        expect(entry.command).toBe('summary')
+    })
 })

tests/loggerIntegration.test.ts

@@ -0,0 +1,123 @@
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { Writable } from 'node:stream'
+import { ChannelType, type ChatInputCommandInteraction, type Client, type TextChannel } from 'discord.js'
+import pino from 'pino'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createLogger } from '../src/components/logger.js'
+import { Capacity } from '../src/commands/capacity.js'
+import { openChannelInfo } from '../src/utils/handlers/chatHistoryHandler.js'
+import { registerCommands, type SlashCommand } from '../src/utils/commands.js'
+
+describe('logger context integration', () => {
+    let output = ''
+    const destination = new Writable({
+        write(chunk, _encoding, callback) {
+            output += chunk.toString()
+            callback()
+        }
+    })
+    const parentLogger = pino({ level: 'trace' }, destination)
+    let workingDirectory: string
+    let tempDirectory: string | undefined
+
+    beforeEach(() => {
+        output = ''
+        workingDirectory = process.cwd()
+        vi.stubEnv('NODE_ENV', 'test')
+    })
+
+    afterEach(() => {
+        process.chdir(workingDirectory)
+        if (tempDirectory)
+            rmSync(tempDirectory, { recursive: true, force: true })
+        vi.unstubAllEnvs()
+    })
+
+    it('retains event and command context in registration and handler logs', async () => {
+        const readyLogger = createLogger({
+            component: 'event',
+            event: 'ClientReady'
+        }, parentLogger)
+        const commandsApi = {
+            fetch: vi.fn().mockResolvedValue(new Map()),
+            cache: { clear: vi.fn() },
+            create: vi.fn(async (command: SlashCommand) => ({
+                name: command.name,
+                options: []
+            }))
+        }
+        const client = {
+            application: { commands: commandsApi }
+        } as unknown as Client
+        const mockCommand = {
+            name: 'test-command',
+            description: 'test command',
+            run: vi.fn()
+        } as unknown as SlashCommand
+
+        registerCommands(client, [mockCommand], readyLogger)
+
+        const commandLogger = createLogger({
+            component: 'command',
+            command: 'modify-capacity'
+        }, createLogger({
+            component: 'event',
+            event: 'InteractionCreate'
+        }, parentLogger))
+        const interaction = {
+            channelId: 'test-channel',
+            commandName: 'modify-capacity',
+            user: { username: 'test-user' },
+            options: {
+                getNumber: () => 8,
+                get: () => ({ value: 8 })
+            },
+            reply: vi.fn()
+        } as unknown as ChatInputCommandInteraction
+        const commandClient = {
+            channels: {
+                fetch: vi.fn().mockResolvedValue({ type: ChannelType.GuildText })
+            }
+        } as unknown as Client
+
+        tempDirectory = mkdtempSync(join(tmpdir(), 'discord-ollama-logger-'))
+        process.chdir(tempDirectory)
+
+        await Capacity.run(commandClient, interaction, commandLogger)
+        await openChannelInfo(commandLogger, 'test-channel', {
+            id: 'test-channel',
+            name: 'test'
+        } as TextChannel, 'test-user')
+
+        await new Promise(resolve => setImmediate(resolve))
+        const entries = output.trim().split('\n').map(line => JSON.parse(line))
+
+        const registration = entries.find(entry => entry.msg === 'Registered command on Discord')
+        expect(registration).toMatchObject({
+            event: 'ClientReady',
+            command: 'test-command',
+            msg: 'Registered command on Discord'
+        })
+
+        const configuration = entries.find(entry => entry.msg === 'Created configuration file')
+        expect(configuration).toMatchObject({
+            event: 'InteractionCreate',
+            component: 'command',
+            command: 'modify-capacity',
+            msg: 'Created configuration file'
+        })
+        expect(configuration.caller).toMatch(/configHandler\.ts:\d+:\d+/)
+
+        const history = entries.find(entry => entry.msg === 'Created channel history')
+        expect(history).toMatchObject({
+            event: 'InteractionCreate',
+            component: 'command',
+            command: 'modify-capacity',
+            msg: 'Created channel history'
+        })
+        expect(history.caller).toMatch(/chatHistoryHandler\.ts:\d+:\d+/)
+
+    })
+})