+3

.env.example

··· 4 4 PDS_URL=https://your-pds.example.com 5 5 JETSTREAM_URL=wss://jetstream2.us-east.bsky.network/subscribe 6 6 7 7 + # Logging 8 8 + LOG_LEVEL=info # debug | info | warn | error | fatal 9 9 + 7 10 # Database 8 11 DATABASE_URL=postgres://atbb:atbb@localhost:5432/atbb 9 12

+1

apps/appview/package.json

··· 16 16 }, 17 17 "dependencies": { 18 18 "@atbb/atproto": "workspace:*", 19 19 + "@atbb/logger": "workspace:*", 19 20 "@atbb/db": "workspace:*", 20 21 "@atbb/lexicon": "workspace:*", 21 22 "@atproto/api": "^0.15.0",

+28 -14

apps/appview/src/index.ts

··· 10 10 11 11 // Create application context with all dependencies 12 12 const ctx = await createAppContext(config); 13 13 + const { logger } = ctx; 13 14 14 15 // Wire BackfillManager ↔ FirehoseService (two-phase init: both exist now) 15 16 if (ctx.backfillManager) { ··· 19 20 20 21 // Seed default roles if enabled 21 22 if (process.env.SEED_DEFAULT_ROLES !== "false") { 22 22 - console.log("Seeding default roles..."); 23 23 + logger.info("Seeding default roles"); 23 24 const result = await seedDefaultRoles(ctx); 24 24 - console.log("Default roles seeded", { 25 25 + logger.info("Default roles seeded", { 25 26 created: result.created, 26 27 skipped: result.skipped, 27 28 }); 28 29 } else { 29 29 - console.log("Role seeding disabled via SEED_DEFAULT_ROLES=false"); 30 30 + logger.info("Role seeding disabled via SEED_DEFAULT_ROLES=false"); 30 31 } 31 32 32 33 // Create Hono app ··· 39 40 port: config.port, 40 41 }, 41 42 (info) => { 42 42 - console.log(`atBB AppView listening on http://localhost:${info.port}`); 43 43 + logger.info("Server started", { 44 44 + url: `http://localhost:${info.port}`, 45 45 + port: info.port, 46 46 + }); 43 47 } 44 48 ); 45 49 46 50 // Start firehose subscription 47 51 ctx.firehose.start().catch((error) => { 48 48 - console.error("Failed to start firehose:", error); 52 52 + logger.fatal("Failed to start firehose", { 53 53 + error: error instanceof Error ? error.message : String(error), 54 54 + }); 49 55 process.exit(1); 50 56 }); 51 57 52 58 // Graceful shutdown handler 53 59 const shutdown = async (signal: string) => { 54 54 - console.log(`\nReceived ${signal}, shutting down gracefully...`); 60 60 + logger.info("Shutdown initiated", { signal }); 55 61 56 62 try { 57 63 await destroyAppContext(ctx); 58 64 59 65 server.close(() => { 60 60 - console.log("Server closed"); 66 66 + logger.info("Server closed"); 61 67 process.exit(0); 62 68 }); 63 69 64 70 setTimeout(() => { 65 65 - console.error("Forced shutdown after timeout"); 71 71 + logger.error("Forced shutdown after timeout"); 66 72 process.exit(1); 67 73 }, 10000); 68 74 } catch (error) { 69 69 - console.error("Error during shutdown:", error); 75 75 + logger.error("Error during shutdown", { 76 76 + error: error instanceof Error ? error.message : String(error), 77 77 + }); 70 78 process.exit(1); 71 79 } 72 80 }; ··· 76 84 } 77 85 78 86 main().catch((error) => { 79 79 - console.error("Fatal error during startup:"); 80 80 - console.error(error?.message || String(error)); 81 81 - if (error?.stack) { 82 82 - console.error(error.stack); 83 83 - } 87 87 + // Logger may not be initialized yet — fall back to structured stderr 88 88 + process.stderr.write( 89 89 + JSON.stringify({ 90 90 + timestamp: new Date().toISOString(), 91 91 + level: "fatal", 92 92 + message: "Fatal error during startup", 93 93 + service: "atbb-appview", 94 94 + error: error?.message || String(error), 95 95 + stack: error?.stack, 96 96 + }) + "\n" 97 97 + ); 84 98 process.exit(1); 85 99 });

+25 -3

apps/appview/src/lib/__tests__/app-context.test.ts

··· 37 37 })), 38 38 })); 39 39 40 40 + vi.mock("@atbb/logger", () => ({ 41 41 + createLogger: vi.fn(() => ({ 42 42 + debug: vi.fn(), 43 43 + info: vi.fn(), 44 44 + warn: vi.fn(), 45 45 + error: vi.fn(), 46 46 + fatal: vi.fn(), 47 47 + child: vi.fn(() => ({ 48 48 + debug: vi.fn(), 49 49 + info: vi.fn(), 50 50 + warn: vi.fn(), 51 51 + error: vi.fn(), 52 52 + fatal: vi.fn(), 53 53 + child: vi.fn(), 54 54 + shutdown: vi.fn(), 55 55 + })), 56 56 + shutdown: vi.fn(), 57 57 + })), 58 58 + })); 59 59 + 40 60 describe("AppContext", () => { 41 61 let config: AppConfig; 42 62 ··· 47 67 databaseUrl: "postgres://localhost/test", 48 68 jetstreamUrl: "wss://jetstream.example.com", 49 69 pdsUrl: "https://pds.example.com", 70 70 + logLevel: "info", 50 71 oauthPublicUrl: "http://localhost:3000", 51 72 sessionSecret: "test-secret-with-minimum-32-chars-for-validation", 52 73 sessionTtlDays: 7, ··· 68 89 }); 69 90 70 91 it("sets forumAgent to null when credentials are missing", async () => { 71 71 - const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {}); 72 92 config.forumHandle = undefined; 73 93 config.forumPassword = undefined; 74 94 75 95 const ctx = await createAppContext(config); 76 96 77 97 expect(ctx.forumAgent).toBeNull(); 78 78 - expect(warnSpy).toHaveBeenCalled(); 79 79 - warnSpy.mockRestore(); 98 98 + expect(ctx.logger.warn).toHaveBeenCalledWith( 99 99 + "ForumAgent credentials missing", 100 100 + expect.objectContaining({ operation: "createAppContext" }) 101 101 + ); 80 102 }); 81 103 }); 82 104

+20 -18

apps/appview/src/lib/__tests__/backfill-manager.test.ts

··· 4 4 import type { AppConfig } from "../config.js"; 5 5 import { AtpAgent } from "@atproto/api"; 6 6 import type { Indexer } from "../indexer.js"; 7 7 + import { createMockLogger } from "./mock-logger.js"; 7 8 8 9 vi.mock("@atproto/api", () => ({ 9 10 AtpAgent: vi.fn().mockImplementation(() => ({ ··· 38 39 describe("BackfillManager", () => { 39 40 let mockDb: Database; 40 41 let manager: BackfillManager; 42 42 + let mockLogger: ReturnType<typeof createMockLogger>; 41 43 42 44 beforeEach(() => { 43 45 mockDb = { ··· 50 52 }), 51 53 } as unknown as Database; 52 54 53 53 - manager = new BackfillManager(mockDb, mockConfig()); 55 55 + mockLogger = createMockLogger(); 56 56 + manager = new BackfillManager(mockDb, mockConfig(), mockLogger); 54 57 }); 55 58 56 59 afterEach(() => { ··· 257 260 258 261 it("returns error stats when indexer is not set", async () => { 259 262 const mockAgent = new AtpAgent({ service: "https://pds.example.com" }); 260 260 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 261 263 // No setIndexer call — indexer is null 262 264 const stats = await manager.syncRepoRecords("did:plc:user", "space.atbb.post", mockAgent); 263 265 expect(stats.errors).toBe(1); 264 264 - expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("indexer_not_set")); 265 265 - consoleSpy.mockRestore(); 266 266 + expect(mockLogger.error).toHaveBeenCalledWith( 267 267 + "backfill.sync_skipped", 268 268 + expect.objectContaining({ reason: "indexer_not_set" }) 269 269 + ); 266 270 }); 267 271 268 272 it("handles PDS connection failure gracefully", async () => { ··· 336 340 }), 337 341 } as unknown as Database; 338 342 339 339 - manager = new BackfillManager(mockDb, mockConfig()); 343 343 + manager = new BackfillManager(mockDb, mockConfig(), createMockLogger()); 340 344 manager.setIndexer(mockIndexer); 341 345 342 346 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ ··· 381 385 }), 382 386 } as unknown as Database; 383 387 384 384 - manager = new BackfillManager(mockDb, mockConfig()); 388 388 + manager = new BackfillManager(mockDb, mockConfig(), createMockLogger()); 385 389 manager.setIndexer(mockIndexer); 386 390 387 391 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ ··· 428 432 }), 429 433 } as unknown as Database; 430 434 431 431 - manager = new BackfillManager(mockDb, mockConfig()); 435 435 + manager = new BackfillManager(mockDb, mockConfig(), createMockLogger()); 432 436 manager.setIndexer(mockIndexer); 433 437 434 438 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ ··· 497 501 }), 498 502 } as unknown as Database; 499 503 500 500 - manager = new BackfillManager(mockDb, mockConfig({ backfillConcurrency: 5 })); 504 504 + manager = new BackfillManager(mockDb, mockConfig({ backfillConcurrency: 5 }), createMockLogger()); 501 505 manager.setIndexer(mockIndexer); 502 506 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ 503 507 com: { atproto: { repo: { listRecords: mockListRecords } } }, ··· 567 571 }), 568 572 } as unknown as Database; 569 573 570 570 - manager = new BackfillManager(mockDb, mockConfig({ backfillConcurrency: 1 })); 574 574 + manager = new BackfillManager(mockDb, mockConfig({ backfillConcurrency: 1 }), createMockLogger()); 571 575 manager.setIndexer(mockIndexer); 572 576 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ 573 577 com: { atproto: { repo: { listRecords: mockListRecords } } }, ··· 597 601 }), 598 602 } as unknown as Database; 599 603 600 600 - manager = new BackfillManager(mockDb, mockConfig()); 604 604 + manager = new BackfillManager(mockDb, mockConfig(), createMockLogger()); 601 605 manager.setIndexer(mockIndexer); 602 606 603 607 await expect(manager.performBackfill(BackfillStatus.FullSync)) ··· 631 635 }), 632 636 } as any); 633 637 634 634 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 635 638 const result = await manager.checkForInterruptedBackfill(); 636 639 expect(result).toBeNull(); 637 637 - expect(consoleSpy).toHaveBeenCalled(); 638 638 - consoleSpy.mockRestore(); 640 640 + expect(mockLogger.error).toHaveBeenCalled(); 639 641 }); 640 642 641 643 it("returns interrupted backfill row when one exists", async () => { ··· 736 738 }), 737 739 } as unknown as Database; 738 740 739 739 - manager = new BackfillManager(mockDb, mockConfig({ backfillConcurrency: 5 })); 741 741 + manager = new BackfillManager(mockDb, mockConfig({ backfillConcurrency: 5 }), createMockLogger()); 740 742 manager.setIndexer(mockIndexer); 741 743 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ 742 744 com: { atproto: { repo: { listRecords: mockListRecords } } }, ··· 781 783 }), 782 784 } as unknown as Database; 783 785 784 784 - manager = new BackfillManager(mockDb, mockConfig()); 786 786 + manager = new BackfillManager(mockDb, mockConfig(), createMockLogger()); 785 787 manager.setIndexer(mockIndexer); 786 788 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ 787 789 com: { atproto: { repo: { listRecords: vi.fn() } } }, ··· 828 830 }), 829 831 } as unknown as Database; 830 832 831 831 - manager = new BackfillManager(mockDb, mockConfig()); 833 833 + manager = new BackfillManager(mockDb, mockConfig(), createMockLogger()); 832 834 manager.setIndexer(mockIndexer); 833 835 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ 834 836 com: { atproto: { repo: { listRecords: vi.fn() } } }, ··· 863 865 update: mockUpdate, 864 866 } as unknown as Database; 865 867 866 866 - manager = new BackfillManager(mockDb, mockConfig()); 868 868 + manager = new BackfillManager(mockDb, mockConfig(), createMockLogger()); 867 869 manager.setIndexer(mockIndexer); 868 870 869 871 await expect(manager.resumeBackfill(interrupted)) ··· 908 910 }), 909 911 } as unknown as Database; 910 912 911 911 - manager = new BackfillManager(mockDb, mockConfig()); 913 913 + manager = new BackfillManager(mockDb, mockConfig(), createMockLogger()); 912 914 manager.setIndexer(mockIndexer); 913 915 vi.spyOn(manager as any, "createAgentForPds").mockReturnValue({ 914 916 com: { atproto: { repo: { listRecords: vi.fn() } } },

+15 -38

apps/appview/src/lib/__tests__/circuit-breaker.test.ts

··· 1 1 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest"; 2 2 import { CircuitBreaker } from "../circuit-breaker.js"; 3 3 + import { createMockLogger } from "./mock-logger.js"; 3 4 4 5 describe("CircuitBreaker", () => { 5 6 let onBreak: ReturnType<typeof vi.fn>; 6 7 let circuitBreaker: CircuitBreaker; 8 8 + let mockLogger: ReturnType<typeof createMockLogger>; 7 9 8 10 beforeEach(() => { 9 11 onBreak = vi.fn().mockResolvedValue(undefined); 12 12 + mockLogger = createMockLogger(); 10 13 }); 11 14 12 15 afterEach(() => { ··· 16 19 describe("Construction", () => { 17 20 it("should initialize with maxFailures and onBreak callback", () => { 18 21 expect(() => { 19 19 - circuitBreaker = new CircuitBreaker(5, onBreak); 22 22 + circuitBreaker = new CircuitBreaker(5, onBreak, mockLogger); 20 23 }).not.toThrow(); 21 24 22 25 expect(circuitBreaker.getFailureCount()).toBe(0); ··· 25 28 26 29 describe("execute", () => { 27 30 beforeEach(() => { 28 28 - circuitBreaker = new CircuitBreaker(3, onBreak); 31 31 + circuitBreaker = new CircuitBreaker(3, onBreak, mockLogger); 29 32 }); 30 33 31 34 it("should execute operation successfully and reset counter", async () => { ··· 39 42 }); 40 43 41 44 it("should track consecutive failures", async () => { 42 42 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 43 45 const operation = vi.fn().mockRejectedValue(new Error("Operation failed")); 44 46 45 47 await circuitBreaker.execute(operation, "test-operation"); ··· 49 51 expect(circuitBreaker.getFailureCount()).toBe(2); 50 52 51 53 expect(onBreak).not.toHaveBeenCalled(); 52 52 - 53 53 - consoleSpy.mockRestore(); 54 54 }); 55 55 56 56 it("should trigger onBreak when max failures reached", async () => { 57 57 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 58 57 const operation = vi.fn().mockRejectedValue(new Error("Operation failed")); 59 58 60 59 // Fail 3 times (maxFailures = 3) ··· 64 63 65 64 expect(circuitBreaker.getFailureCount()).toBe(3); 66 65 expect(onBreak).toHaveBeenCalledOnce(); 67 67 - 68 68 - consoleSpy.mockRestore(); 69 66 }); 70 67 71 68 it("should log failures with operation name", async () => { 72 72 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 73 69 const operation = vi.fn().mockRejectedValue(new Error("Operation failed")); 74 70 75 71 await circuitBreaker.execute(operation, "custom-operation"); 76 72 77 77 - expect(consoleSpy).toHaveBeenCalledWith( 78 78 - expect.stringContaining("custom-operation"), 79 79 - expect.any(Error) 73 73 + expect(mockLogger.error).toHaveBeenCalledWith( 74 74 + expect.stringContaining("Circuit breaker"), 75 75 + expect.objectContaining({ operationName: "custom-operation" }) 80 76 ); 81 81 - 82 82 - consoleSpy.mockRestore(); 83 77 }); 84 78 85 79 it("should log when circuit breaks", async () => { 86 86 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 87 80 const operation = vi.fn().mockRejectedValue(new Error("Operation failed")); 88 81 89 82 // Trigger circuit breaker ··· 91 84 await circuitBreaker.execute(operation, "test-operation"); 92 85 await circuitBreaker.execute(operation, "test-operation"); 93 86 94 94 - expect(consoleSpy).toHaveBeenCalledWith( 95 95 - expect.stringContaining("[CIRCUIT BREAKER] Max consecutive failures") 87 87 + expect(mockLogger.error).toHaveBeenCalledWith( 88 88 + expect.stringContaining("max consecutive failures"), 89 89 + expect.objectContaining({ maxFailures: 3 }) 96 90 ); 97 97 - 98 98 - consoleSpy.mockRestore(); 99 91 }); 100 92 101 93 it("should reset counter after successful operation", async () => { 102 102 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 103 94 const failingOp = vi.fn().mockRejectedValue(new Error("Failed")); 104 95 const successOp = vi.fn().mockResolvedValue("success"); 105 96 ··· 114 105 115 106 // Verify onBreak was never called 116 107 expect(onBreak).not.toHaveBeenCalled(); 117 117 - 118 118 - consoleSpy.mockRestore(); 119 108 }); 120 109 }); 121 110 122 111 describe("reset", () => { 123 112 beforeEach(() => { 124 124 - circuitBreaker = new CircuitBreaker(3, onBreak); 113 113 + circuitBreaker = new CircuitBreaker(3, onBreak, mockLogger); 125 114 }); 126 115 127 116 it("should reset failure counter", async () => { 128 128 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 129 117 const operation = vi.fn().mockRejectedValue(new Error("Failed")); 130 118 131 119 await circuitBreaker.execute(operation, "test-operation"); ··· 134 122 135 123 circuitBreaker.reset(); 136 124 expect(circuitBreaker.getFailureCount()).toBe(0); 137 137 - 138 138 - consoleSpy.mockRestore(); 139 125 }); 140 126 }); 141 127 142 128 describe("getFailureCount", () => { 143 129 beforeEach(() => { 144 144 - circuitBreaker = new CircuitBreaker(3, onBreak); 130 130 + circuitBreaker = new CircuitBreaker(3, onBreak, mockLogger); 145 131 }); 146 132 147 133 it("should return current failure count", async () => { 148 148 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 149 134 const operation = vi.fn().mockRejectedValue(new Error("Failed")); 150 135 151 136 expect(circuitBreaker.getFailureCount()).toBe(0); ··· 155 140 156 141 await circuitBreaker.execute(operation, "test-operation"); 157 142 expect(circuitBreaker.getFailureCount()).toBe(2); 158 158 - 159 159 - consoleSpy.mockRestore(); 160 143 }); 161 144 }); 162 145 163 146 describe("Edge Cases", () => { 164 147 it("should handle onBreak callback errors", async () => { 165 165 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 166 148 const failingOnBreak = vi.fn().mockRejectedValue(new Error("onBreak failed")); 167 167 - circuitBreaker = new CircuitBreaker(2, failingOnBreak); 149 149 + circuitBreaker = new CircuitBreaker(2, failingOnBreak, mockLogger); 168 150 169 151 const operation = vi.fn().mockRejectedValue(new Error("Operation failed")); 170 152 ··· 182 164 } 183 165 184 166 expect(failingOnBreak).toHaveBeenCalled(); 185 185 - 186 186 - consoleSpy.mockRestore(); 187 167 }); 188 168 189 169 it("should handle maxFailures of 1", async () => { 190 190 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 191 191 - circuitBreaker = new CircuitBreaker(1, onBreak); 170 170 + circuitBreaker = new CircuitBreaker(1, onBreak, mockLogger); 192 171 193 172 const operation = vi.fn().mockRejectedValue(new Error("Failed")); 194 173 ··· 196 175 197 176 expect(circuitBreaker.getFailureCount()).toBe(1); 198 177 expect(onBreak).toHaveBeenCalledOnce(); 199 199 - 200 200 - consoleSpy.mockRestore(); 201 178 }); 202 179 }); 203 180 });

+11 -15

apps/appview/src/lib/__tests__/cursor-manager.test.ts

··· 1 1 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest"; 2 2 import { CursorManager } from "../cursor-manager.js"; 3 3 + import { createMockLogger } from "./mock-logger.js"; 3 4 import type { Database } from "@atbb/db"; 4 5 5 6 describe("CursorManager", () => { 6 7 let mockDb: Database; 7 8 let cursorManager: CursorManager; 9 9 + let mockLogger: ReturnType<typeof createMockLogger>; 8 10 9 11 beforeEach(() => { 12 12 + mockLogger = createMockLogger(); 13 13 + 10 14 // Create mock database with common patterns 11 15 const mockInsert = vi.fn().mockReturnValue({ 12 16 values: vi.fn().mockReturnValue({ ··· 27 31 select: mockSelect, 28 32 } as unknown as Database; 29 33 30 30 - cursorManager = new CursorManager(mockDb); 34 34 + cursorManager = new CursorManager(mockDb, mockLogger); 31 35 }); 32 36 33 37 afterEach(() => { ··· 66 70 }); 67 71 68 72 it("should return null and log error on database failure", async () => { 69 69 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 70 70 - 71 73 // Mock database error 72 74 vi.spyOn(mockDb, "select").mockReturnValue({ 73 75 from: vi.fn().mockReturnValue({ ··· 79 81 80 82 const cursor = await cursorManager.load(); 81 83 expect(cursor).toBeNull(); 82 82 - expect(consoleSpy).toHaveBeenCalledWith( 83 83 - "Failed to load cursor from database:", 84 84 - expect.any(Error) 84 84 + expect(mockLogger.error).toHaveBeenCalledWith( 85 85 + "Failed to load cursor from database", 86 86 + expect.objectContaining({ error: "Database error" }) 85 87 ); 86 86 - 87 87 - consoleSpy.mockRestore(); 88 88 }); 89 89 90 90 it("should allow custom service name", async () => { ··· 122 122 }); 123 123 124 124 it("should not throw on database failure", async () => { 125 125 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 126 126 - 127 125 // Mock database error 128 126 vi.spyOn(mockDb, "insert").mockReturnValue({ 129 127 values: vi.fn().mockReturnValue({ ··· 134 132 // Should not throw 135 133 await expect(cursorManager.update(1234567890000000)).resolves.toBeUndefined(); 136 134 137 137 - expect(consoleSpy).toHaveBeenCalledWith( 138 138 - "Failed to update cursor:", 139 139 - expect.any(Error) 135 135 + expect(mockLogger.error).toHaveBeenCalledWith( 136 136 + "Failed to update cursor", 137 137 + expect.objectContaining({ error: "Database error" }) 140 138 ); 141 141 - 142 142 - consoleSpy.mockRestore(); 143 139 }); 144 140 145 141 it("should allow custom service name", async () => {

+24 -25

apps/appview/src/lib/__tests__/firehose.test.ts

··· 1 1 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest"; 2 2 import { FirehoseService } from "../firehose.js"; 3 3 + import { createMockLogger } from "./mock-logger.js"; 3 4 import type { Database } from "@atbb/db"; 4 5 import { BackfillStatus } from "../backfill-manager.js"; 5 6 ··· 68 69 describe("FirehoseService", () => { 69 70 let mockDb: Database; 70 71 let firehoseService: FirehoseService; 72 72 + let mockLogger: ReturnType<typeof createMockLogger>; 71 73 72 74 beforeEach(() => { 75 75 + mockLogger = createMockLogger(); 76 76 + 73 77 // Create mock database 74 78 const mockInsert = vi.fn().mockReturnValue({ 75 79 values: vi.fn().mockReturnValue({ ··· 100 104 expect(() => { 101 105 firehoseService = new FirehoseService( 102 106 mockDb, 103 103 - "wss://jetstream.example.com" 107 107 + "wss://jetstream.example.com", 108 108 + mockLogger 104 109 ); 105 110 }).not.toThrow(); 106 111 }); ··· 110 115 111 116 firehoseService = new FirehoseService( 112 117 mockDb, 113 113 - "wss://jetstream.example.com" 118 118 + "wss://jetstream.example.com", 119 119 + mockLogger 114 120 ); 115 121 116 116 - expect(Indexer).toHaveBeenCalledWith(mockDb); 122 122 + expect(Indexer).toHaveBeenCalledWith(mockDb, mockLogger); 117 123 }); 118 124 }); 119 125 ··· 121 127 beforeEach(() => { 122 128 firehoseService = new FirehoseService( 123 129 mockDb, 124 124 - "wss://jetstream.example.com" 130 130 + "wss://jetstream.example.com", 131 131 + mockLogger 125 132 ); 126 133 }); 127 134 ··· 141 148 }); 142 149 143 150 it("should not start if already running", async () => { 144 144 - const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {}); 145 145 - 146 151 await firehoseService.start(); 147 152 await firehoseService.start(); // Second call 148 153 149 149 - expect(consoleSpy).toHaveBeenCalledWith( 154 154 + expect(mockLogger.warn).toHaveBeenCalledWith( 150 155 "Firehose service is already running" 151 156 ); 152 152 - 153 153 - consoleSpy.mockRestore(); 154 157 }); 155 158 }); 156 159 ··· 158 161 beforeEach(() => { 159 162 firehoseService = new FirehoseService( 160 163 mockDb, 161 161 - "wss://jetstream.example.com" 164 164 + "wss://jetstream.example.com", 165 165 + mockLogger 162 166 ); 163 167 }); 164 168 ··· 173 177 }), 174 178 } as any); 175 179 176 176 - const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {}); 177 177 - 178 180 await firehoseService.start(); 179 181 180 182 // Verify cursor was loaded and logged 181 181 - expect(consoleSpy).toHaveBeenCalledWith( 182 182 - expect.stringContaining("Resuming from cursor") 183 183 + expect(mockLogger.info).toHaveBeenCalledWith( 184 184 + "Resuming from cursor", 185 185 + expect.any(Object) 183 186 ); 184 184 - 185 185 - consoleSpy.mockRestore(); 186 187 }); 187 188 188 189 it("should start from beginning if no cursor exists", async () => { ··· 206 207 beforeEach(() => { 207 208 firehoseService = new FirehoseService( 208 209 mockDb, 209 209 - "wss://jetstream.example.com" 210 210 + "wss://jetstream.example.com", 211 211 + mockLogger 210 212 ); 211 213 }); 212 214 213 215 it("continues to start firehose when backfill throws on startup", async () => { 214 214 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 215 216 const mockBackfillManager = { 216 217 checkForInterruptedBackfill: vi.fn().mockRejectedValue(new Error("DB connection lost")), 217 218 checkIfNeeded: vi.fn(), ··· 224 225 await firehoseService.start(); 225 226 226 227 expect(firehoseService.isRunning()).toBe(true); 227 227 - expect(consoleSpy).toHaveBeenCalledWith( 228 228 - expect.stringContaining("firehose.backfill.startup_error") 228 228 + expect(mockLogger.error).toHaveBeenCalledWith( 229 229 + "Backfill skipped due to startup error — firehose will start without it", 230 230 + expect.objectContaining({ event: "firehose.backfill.startup_error" }) 229 231 ); 230 230 - consoleSpy.mockRestore(); 231 232 }); 232 233 }); 233 234 }); ··· 256 257 select: mockSelect, 257 258 } as unknown as Database; 258 259 259 259 - vi.spyOn(console, "log").mockImplementation(() => {}); 260 260 - vi.spyOn(console, "error").mockImplementation(() => {}); 261 261 - vi.spyOn(console, "warn").mockImplementation(() => {}); 262 262 - firehoseService = new FirehoseService(mockDb, "wss://jetstream.example.com"); 260 260 + const mockLogger = createMockLogger(); 261 261 + firehoseService = new FirehoseService(mockDb, "wss://jetstream.example.com", mockLogger); 263 262 }); 264 263 265 264 afterEach(() => {

+4 -1

apps/appview/src/lib/__tests__/indexer-ban-enforcer.test.ts

··· 1 1 import { describe, it, expect, beforeEach, vi } from "vitest"; 2 2 import { BanEnforcer } from "../ban-enforcer.js"; 3 3 + import { createMockLogger } from "./mock-logger.js"; 3 4 import type { Database } from "@atbb/db"; 4 5 5 6 const createMockDb = () => { ··· 15 16 describe("BanEnforcer", () => { 16 17 let mockDb: Database; 17 18 let enforcer: BanEnforcer; 19 19 + let mockLogger: ReturnType<typeof createMockLogger>; 18 20 19 21 beforeEach(() => { 20 22 vi.clearAllMocks(); 21 23 mockDb = createMockDb(); 22 22 - enforcer = new BanEnforcer(mockDb); 24 24 + mockLogger = createMockLogger(); 25 25 + enforcer = new BanEnforcer(mockDb, mockLogger); 23 26 }); 24 27 25 28 describe("isBanned", () => {

+1 -1

apps/appview/src/lib/__tests__/indexer-board-helpers.test.ts

··· 10 10 11 11 beforeEach(async () => { 12 12 ctx = await createTestContext(); 13 13 - indexer = new Indexer(ctx.db); 13 13 + indexer = new Indexer(ctx.db, ctx.logger); 14 14 }); 15 15 16 16 afterEach(async () => {

+1 -1

apps/appview/src/lib/__tests__/indexer-boards.test.ts

··· 17 17 18 18 beforeEach(async () => { 19 19 ctx = await createTestContext(); 20 20 - indexer = new Indexer(ctx.db); 20 20 + indexer = new Indexer(ctx.db, ctx.logger); 21 21 22 22 // Get the forum ID created by createTestContext 23 23 const [forum] = await ctx.db

+1 -1

apps/appview/src/lib/__tests__/indexer-roles.test.ts

··· 15 15 16 16 beforeEach(async () => { 17 17 ctx = await createTestContext(); 18 18 - indexer = new Indexer(ctx.db); 18 18 + indexer = new Indexer(ctx.db, ctx.logger); 19 19 }); 20 20 21 21 afterEach(async () => {

+19 -25

apps/appview/src/lib/__tests__/indexer.test.ts

··· 1 1 import { describe, it, expect, beforeEach, vi } from "vitest"; 2 2 import { Indexer } from "../indexer.js"; 3 3 + import { createMockLogger } from "./mock-logger.js"; 3 4 import type { Database } from "@atbb/db"; 4 5 import { memberships } from "@atbb/db"; 5 6 import type { CommitCreateEvent, CommitUpdateEvent, CommitDeleteEvent } from "@skyware/jetstream"; ··· 61 62 describe("Indexer", () => { 62 63 let mockDb: Database; 63 64 let indexer: Indexer; 65 65 + let mockLogger: ReturnType<typeof createMockLogger>; 64 66 65 67 beforeEach(() => { 66 68 vi.clearAllMocks(); 67 69 mockDb = createMockDb(); 68 68 - indexer = new Indexer(mockDb); 70 70 + mockLogger = createMockLogger(); 71 71 + indexer = new Indexer(mockDb, mockLogger); 69 72 }); 70 73 71 74 describe("Post Handler", () => { ··· 154 157 return await callback(txContext); 155 158 }); 156 159 157 157 - const indexer = new Indexer(mockDbWithTracking); 160 160 + const indexer = new Indexer(mockDbWithTracking, mockLogger); 158 161 const boardUri = "at://did:plc:forum/space.atbb.forum.board/board1"; 159 162 160 163 const event: CommitCreateEvent<"space.atbb.post"> = { ··· 446 449 await callback(txContext); 447 450 }); 448 451 449 449 - const indexer = new Indexer(mockDbWithError); 452 452 + const indexer = new Indexer(mockDbWithError, mockLogger); 450 453 const event: CommitCreateEvent<"space.atbb.post"> = { 451 454 did: "did:plc:test", 452 455 time_us: 1234567890, ··· 488 491 await callback(txContext); 489 492 }); 490 493 491 491 - const indexer = new Indexer(mockDbWithError); 494 494 + const indexer = new Indexer(mockDbWithError, mockLogger); 492 495 const event: CommitCreateEvent<"space.atbb.forum.category"> = { 493 496 did: "did:plc:forum", 494 497 time_us: 1234567890, ··· 511 514 }); 512 515 513 516 it("should log error and re-throw when database operation fails", async () => { 514 514 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 515 517 const mockDbWithError = createMockDb(); 516 518 mockDbWithError.transaction = vi.fn().mockRejectedValue(new Error("Database connection lost")); 517 519 518 518 - const indexer = new Indexer(mockDbWithError); 520 520 + const indexer = new Indexer(mockDbWithError, mockLogger); 519 521 const event: CommitCreateEvent<"space.atbb.forum.forum"> = { 520 522 did: "did:plc:forum", 521 523 time_us: 1234567890, ··· 535 537 }; 536 538 537 539 await expect(indexer.handleForumCreate(event)).rejects.toThrow("Database connection lost"); 538 538 - expect(consoleSpy).toHaveBeenCalledWith( 540 540 + expect(mockLogger.error).toHaveBeenCalledWith( 539 541 expect.stringContaining("Failed to index forum create"), 540 540 - expect.any(Error) 542 542 + expect.objectContaining({ error: "Database connection lost" }) 541 543 ); 542 542 - 543 543 - consoleSpy.mockRestore(); 544 544 }); 545 545 }); 546 546 ··· 637 637 return await callback(txContext); 638 638 }); 639 639 640 640 - const indexer = new Indexer(mockDbWithTracking); 640 640 + const indexer = new Indexer(mockDbWithTracking, mockLogger); 641 641 const event: CommitCreateEvent<"space.atbb.membership"> = { 642 642 did: "did:plc:user", 643 643 time_us: 1234567890, ··· 777 777 const mockDbWithError = createMockDb(); 778 778 mockDbWithError.transaction = vi.fn().mockRejectedValue(new Error("Database error")); 779 779 780 780 - const indexer = new Indexer(mockDbWithError); 780 780 + const indexer = new Indexer(mockDbWithError, mockLogger); 781 781 const event: CommitCreateEvent<"space.atbb.post"> = { 782 782 did: "did:plc:test", 783 783 time_us: 1234567890, ··· 803 803 const mockDbWithError = createMockDb(); 804 804 mockDbWithError.transaction = vi.fn().mockRejectedValue(new Error("Update failed")); 805 805 806 806 - const indexer = new Indexer(mockDbWithError); 806 806 + const indexer = new Indexer(mockDbWithError, mockLogger); 807 807 const event: CommitUpdateEvent<"space.atbb.forum.forum"> = { 808 808 did: "did:plc:forum", 809 809 time_us: 1234567890, ··· 833 833 }), 834 834 }); 835 835 836 836 - const indexer = new Indexer(mockDbWithError); 836 836 + const indexer = new Indexer(mockDbWithError, mockLogger); 837 837 const event: CommitDeleteEvent<"space.atbb.post"> = { 838 838 did: "did:plc:test", 839 839 time_us: 1234567890, ··· 855 855 where: vi.fn().mockRejectedValue(new Error("Hard delete failed")), 856 856 }); 857 857 858 858 - const indexer = new Indexer(mockDbWithError); 858 858 + const indexer = new Indexer(mockDbWithError, mockLogger); 859 859 const event: CommitDeleteEvent<"space.atbb.forum.forum"> = { 860 860 did: "did:plc:forum", 861 861 time_us: 1234567890, ··· 872 872 }); 873 873 874 874 it("re-throws errors from handleModActionDelete and logs with context", async () => { 875 875 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 876 875 (mockDb.transaction as ReturnType<typeof vi.fn>).mockRejectedValueOnce( 877 876 new Error("Transaction aborted") 878 877 ); ··· 890 889 } as any; 891 890 892 891 await expect(indexer.handleModActionDelete(event)).rejects.toThrow("Transaction aborted"); 893 893 - expect(consoleSpy).toHaveBeenCalledWith( 894 894 - expect.stringContaining("Failed to delete modAction:"), 895 895 - expect.any(Error) 892 892 + expect(mockLogger.error).toHaveBeenCalledWith( 893 893 + expect.stringContaining("Failed to delete modAction"), 894 894 + expect.objectContaining({ error: "Transaction aborted" }) 896 895 ); 897 897 - 898 898 - consoleSpy.mockRestore(); 899 896 }); 900 897 }); 901 898 ··· 1178 1175 1179 1176 it("logs warning and skips applyBan when ban action has no subject.did", async () => { 1180 1177 const mockBanEnforcer = (indexer as any).banEnforcer; 1181 1181 - const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {}); 1182 1178 1183 1179 // Mock select to return forum found 1184 1180 (mockDb.select as ReturnType<typeof vi.fn>).mockReturnValue({ ··· 1212 1208 await indexer.handleModActionCreate(event); 1213 1209 1214 1210 expect(mockBanEnforcer.applyBan).not.toHaveBeenCalled(); 1215 1215 - expect(consoleSpy).toHaveBeenCalledWith( 1211 1211 + expect(mockLogger.warn).toHaveBeenCalledWith( 1216 1212 expect.stringContaining("missing subject.did"), 1217 1213 expect.any(Object) 1218 1214 ); 1219 1219 - 1220 1220 - consoleSpy.mockRestore(); 1221 1215 }); 1222 1216 1223 1217 it("calls liftBan when an unban mod action is indexed", async () => {

+25

apps/appview/src/lib/__tests__/mock-logger.ts

··· 1 1 + import { vi } from "vitest"; 2 2 + import type { Logger } from "@atbb/logger"; 3 3 + 4 4 + /** 5 5 + * Create a mock Logger for unit tests. 6 6 + * All methods are vi.fn() spies so tests can assert on calls. 7 7 + */ 8 8 + export function createMockLogger(): Logger & { 9 9 + debug: ReturnType<typeof vi.fn>; 10 10 + info: ReturnType<typeof vi.fn>; 11 11 + warn: ReturnType<typeof vi.fn>; 12 12 + error: ReturnType<typeof vi.fn>; 13 13 + fatal: ReturnType<typeof vi.fn>; 14 14 + } { 15 15 + const mock: Logger = { 16 16 + debug: vi.fn(), 17 17 + info: vi.fn(), 18 18 + warn: vi.fn(), 19 19 + error: vi.fn(), 20 20 + fatal: vi.fn(), 21 21 + child: vi.fn().mockReturnThis(), 22 22 + shutdown: vi.fn().mockResolvedValue(undefined), 23 23 + }; 24 24 + return mock as any; 25 25 + }

+48 -46

apps/appview/src/lib/__tests__/reconnection-manager.test.ts

··· 1 1 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest"; 2 2 import { ReconnectionManager } from "../reconnection-manager.js"; 3 3 + import { createMockLogger } from "./mock-logger.js"; 3 4 4 5 describe("ReconnectionManager", () => { 5 6 let reconnectionManager: ReconnectionManager; 6 7 let reconnectFn: ReturnType<typeof vi.fn>; 8 8 + let mockLogger: ReturnType<typeof createMockLogger>; 7 9 8 10 beforeEach(() => { 9 11 vi.useFakeTimers(); 10 12 reconnectFn = vi.fn().mockResolvedValue(undefined); 13 13 + mockLogger = createMockLogger(); 11 14 }); 12 15 13 16 afterEach(() => { ··· 18 21 describe("Construction", () => { 19 22 it("should initialize with maxAttempts and baseDelayMs", () => { 20 23 expect(() => { 21 21 - reconnectionManager = new ReconnectionManager(5, 1000); 24 24 + reconnectionManager = new ReconnectionManager(5, 1000, mockLogger); 22 25 }).not.toThrow(); 23 26 24 27 expect(reconnectionManager.getAttemptCount()).toBe(0); ··· 27 30 28 31 describe("attemptReconnect", () => { 29 32 beforeEach(() => { 30 30 - reconnectionManager = new ReconnectionManager(3, 1000); 33 33 + reconnectionManager = new ReconnectionManager(3, 1000, mockLogger); 31 34 }); 32 35 33 36 it("should attempt reconnection with exponential backoff", async () => { 34 34 - const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {}); 35 35 - 36 37 // First attempt: 1000ms delay (1000 * 2^0) 37 38 const promise1 = reconnectionManager.attemptReconnect(reconnectFn); 38 38 - expect(consoleSpy).toHaveBeenCalledWith( 39 39 - expect.stringContaining("(1/3) in 1000ms") 39 39 + expect(mockLogger.info).toHaveBeenCalledWith( 40 40 + "Attempting to reconnect", 41 41 + expect.objectContaining({ attempt: 1, maxAttempts: 3, delayMs: 1000 }) 40 42 ); 41 43 await vi.advanceTimersByTimeAsync(1000); 42 44 await promise1; ··· 44 46 45 47 // Second attempt: 2000ms delay (1000 * 2^1) 46 48 const promise2 = reconnectionManager.attemptReconnect(reconnectFn); 47 47 - expect(consoleSpy).toHaveBeenCalledWith( 48 48 - expect.stringContaining("(2/3) in 2000ms") 49 49 + expect(mockLogger.info).toHaveBeenCalledWith( 50 50 + "Attempting to reconnect", 51 51 + expect.objectContaining({ attempt: 2, maxAttempts: 3, delayMs: 2000 }) 49 52 ); 50 53 await vi.advanceTimersByTimeAsync(2000); 51 54 await promise2; ··· 53 56 54 57 // Third attempt: 4000ms delay (1000 * 2^2) 55 58 const promise3 = reconnectionManager.attemptReconnect(reconnectFn); 56 56 - expect(consoleSpy).toHaveBeenCalledWith( 57 57 - expect.stringContaining("(3/3) in 4000ms") 59 59 + expect(mockLogger.info).toHaveBeenCalledWith( 60 60 + "Attempting to reconnect", 61 61 + expect.objectContaining({ attempt: 3, maxAttempts: 3, delayMs: 4000 }) 58 62 ); 59 63 await vi.advanceTimersByTimeAsync(4000); 60 64 await promise3; 61 65 expect(reconnectFn).toHaveBeenCalledTimes(3); 62 62 - 63 63 - consoleSpy.mockRestore(); 64 66 }); 65 67 66 68 it("should throw error when max attempts exceeded", async () => { 67 67 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 68 68 - 69 69 // Exhaust all attempts 70 70 const promise1 = reconnectionManager.attemptReconnect(reconnectFn); 71 71 await vi.runAllTimersAsync(); ··· 84 84 "Max reconnection attempts exceeded" 85 85 ); 86 86 87 87 - expect(consoleSpy).toHaveBeenCalledWith( 88 88 - expect.stringContaining("[FATAL] Max reconnect attempts") 87 87 + expect(mockLogger.fatal).toHaveBeenCalledWith( 88 88 + expect.stringContaining("Max reconnect attempts reached"), 89 89 + expect.objectContaining({ maxAttempts: 3 }) 89 90 ); 90 90 - 91 91 - consoleSpy.mockRestore(); 92 91 }); 93 92 94 93 it("should log reconnection attempts", async () => { 95 95 - const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {}); 96 96 - 97 94 const promise = reconnectionManager.attemptReconnect(reconnectFn); 98 95 await vi.runAllTimersAsync(); 99 96 await promise; 100 97 101 101 - expect(consoleSpy).toHaveBeenCalledWith( 102 102 - expect.stringContaining("Attempting to reconnect") 98 98 + expect(mockLogger.info).toHaveBeenCalledWith( 99 99 + "Attempting to reconnect", 100 100 + expect.any(Object) 103 101 ); 104 104 - 105 105 - consoleSpy.mockRestore(); 106 102 }); 107 103 108 104 it("should propagate errors from reconnectFn", async () => { ··· 119 115 120 116 describe("reset", () => { 121 117 beforeEach(() => { 122 122 - reconnectionManager = new ReconnectionManager(3, 1000); 118 118 + reconnectionManager = new ReconnectionManager(3, 1000, mockLogger); 123 119 }); 124 120 125 121 it("should reset attempt counter", async () => { ··· 136 132 }); 137 133 138 134 it("should allow reconnection after reset", async () => { 139 139 - const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {}); 140 140 - 141 135 // Exhaust all attempts 142 136 const promise1 = reconnectionManager.attemptReconnect(reconnectFn); 143 137 await vi.runAllTimersAsync(); ··· 157 151 reconnectionManager.reset(); 158 152 159 153 const promise4 = reconnectionManager.attemptReconnect(reconnectFn); 160 160 - expect(consoleSpy).toHaveBeenCalledWith( 161 161 - expect.stringContaining("(1/3) in 1000ms") 154 154 + expect(mockLogger.info).toHaveBeenCalledWith( 155 155 + "Attempting to reconnect", 156 156 + expect.objectContaining({ attempt: 1, maxAttempts: 3, delayMs: 1000 }) 162 157 ); 163 158 await vi.runAllTimersAsync(); 164 159 await promise4; 165 165 - 166 166 - consoleSpy.mockRestore(); 167 160 }); 168 161 }); 169 162 170 163 describe("getAttemptCount", () => { 171 164 beforeEach(() => { 172 172 - reconnectionManager = new ReconnectionManager(3, 1000); 165 165 + reconnectionManager = new ReconnectionManager(3, 1000, mockLogger); 173 166 }); 174 167 175 168 it("should return current attempt count", async () => { ··· 189 182 190 183 describe("Edge Cases", () => { 191 184 it("should handle maxAttempts of 1", async () => { 192 192 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 193 193 - reconnectionManager = new ReconnectionManager(1, 1000); 185 185 + reconnectionManager = new ReconnectionManager(1, 1000, mockLogger); 194 186 195 187 const promise = reconnectionManager.attemptReconnect(reconnectFn); 196 188 await vi.runAllTimersAsync(); ··· 202 194 await expect(reconnectionManager.attemptReconnect(reconnectFn)).rejects.toThrow( 203 195 "Max reconnection attempts exceeded" 204 196 ); 205 205 - 206 206 - consoleSpy.mockRestore(); 207 197 }); 208 198 209 199 it("should handle very small base delays", async () => { 210 210 - reconnectionManager = new ReconnectionManager(2, 10); 200 200 + reconnectionManager = new ReconnectionManager(2, 10, mockLogger); 211 201 212 202 const promise = reconnectionManager.attemptReconnect(reconnectFn); 213 203 await vi.advanceTimersByTimeAsync(10); ··· 217 207 }); 218 208 219 209 it("should calculate exponential backoff correctly for many attempts", async () => { 220 220 - const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {}); 221 221 - reconnectionManager = new ReconnectionManager(5, 100); 210 210 + reconnectionManager = new ReconnectionManager(5, 100, mockLogger); 222 211 223 212 // Attempt 1: 100ms (100 * 2^0) 224 213 let promise = reconnectionManager.attemptReconnect(reconnectFn); 225 225 - expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("in 100ms")); 214 214 + expect(mockLogger.info).toHaveBeenCalledWith( 215 215 + "Attempting to reconnect", 216 216 + expect.objectContaining({ delayMs: 100 }) 217 217 + ); 226 218 await vi.runAllTimersAsync(); 227 219 await promise; 228 220 229 221 // Attempt 2: 200ms (100 * 2^1) 230 222 promise = reconnectionManager.attemptReconnect(reconnectFn); 231 231 - expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("in 200ms")); 223 223 + expect(mockLogger.info).toHaveBeenCalledWith( 224 224 + "Attempting to reconnect", 225 225 + expect.objectContaining({ delayMs: 200 }) 226 226 + ); 232 227 await vi.runAllTimersAsync(); 233 228 await promise; 234 229 235 230 // Attempt 3: 400ms (100 * 2^2) 236 231 promise = reconnectionManager.attemptReconnect(reconnectFn); 237 237 - expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("in 400ms")); 232 232 + expect(mockLogger.info).toHaveBeenCalledWith( 233 233 + "Attempting to reconnect", 234 234 + expect.objectContaining({ delayMs: 400 }) 235 235 + ); 238 236 await vi.runAllTimersAsync(); 239 237 await promise; 240 238 241 239 // Attempt 4: 800ms (100 * 2^3) 242 240 promise = reconnectionManager.attemptReconnect(reconnectFn); 243 243 - expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("in 800ms")); 241 241 + expect(mockLogger.info).toHaveBeenCalledWith( 242 242 + "Attempting to reconnect", 243 243 + expect.objectContaining({ delayMs: 800 }) 244 244 + ); 244 245 await vi.runAllTimersAsync(); 245 246 await promise; 246 247 247 248 // Attempt 5: 1600ms (100 * 2^4) 248 249 promise = reconnectionManager.attemptReconnect(reconnectFn); 249 249 - expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("in 1600ms")); 250 250 + expect(mockLogger.info).toHaveBeenCalledWith( 251 251 + "Attempting to reconnect", 252 252 + expect.objectContaining({ delayMs: 1600 }) 253 253 + ); 250 254 await vi.runAllTimersAsync(); 251 255 await promise; 252 252 - 253 253 - consoleSpy.mockRestore(); 254 256 }); 255 257 }); 256 258 });

+28 -12

apps/appview/src/lib/__tests__/route-errors.test.ts

··· 8 8 getForumAgentOrError, 9 9 } from "../route-errors.js"; 10 10 import type { AppContext } from "../app-context.js"; 11 11 + import { createMockLogger } from "./mock-logger.js"; 11 12 12 13 afterEach(() => { 13 14 vi.restoreAllMocks(); ··· 33 34 const app = makeApp((c) => 34 35 handleReadError(c, new Error("fetch failed"), "Failed to read resource", { 35 36 operation: "GET /test", 37 37 + logger: createMockLogger(), 36 38 }) 37 39 ); 38 40 ··· 49 51 const app = makeApp((c) => 50 52 handleReadError(c, new Error("database query failed"), "Failed to read resource", { 51 53 operation: "GET /test", 54 54 + logger: createMockLogger(), 52 55 }) 53 56 ); 54 57 ··· 65 68 const app = makeApp((c) => 66 69 handleReadError(c, new Error("Something went wrong"), "Failed to read resource", { 67 70 operation: "GET /test", 71 71 + logger: createMockLogger(), 68 72 }) 69 73 ); 70 74 ··· 76 80 }); 77 81 78 82 it("logs structured context on error", async () => { 79 79 - const spy = vi.spyOn(console, "error").mockImplementation(() => {}); 83 83 + const mockLogger = createMockLogger(); 80 84 const app = makeApp((c) => 81 85 handleReadError(c, new Error("boom"), "Failed to fetch things", { 82 86 operation: "GET /test", 87 87 + logger: mockLogger, 83 88 resourceId: "123", 84 89 }) 85 90 ); 86 91 87 92 await app.request("/test"); 88 93 89 89 - expect(spy).toHaveBeenCalledWith( 94 94 + expect(mockLogger.error).toHaveBeenCalledWith( 90 95 "Failed to fetch things", 91 96 expect.objectContaining({ 92 97 operation: "GET /test", ··· 97 102 }); 98 103 99 104 it("re-throws TypeError (programming error) and logs CRITICAL", async () => { 100 100 - const spy = vi.spyOn(console, "error").mockImplementation(() => {}); 105 105 + const mockLogger = createMockLogger(); 101 106 const programmingError = new TypeError("Cannot read property of undefined"); 102 107 const app = makeApp((c) => 103 108 handleReadError(c, programmingError, "Failed to read resource", { 104 109 operation: "GET /test", 110 110 + logger: mockLogger, 105 111 }) 106 112 ); 107 113 ··· 110 116 expect(res.status).toBe(500); 111 117 112 118 // CRITICAL log must be emitted before the re-throw 113 113 - expect(spy).toHaveBeenCalledWith( 119 119 + expect(mockLogger.error).toHaveBeenCalledWith( 114 120 "CRITICAL: Programming error in GET /test", 115 121 expect.objectContaining({ 116 122 operation: "GET /test", ··· 120 126 ); 121 127 122 128 // Normal error log must NOT be emitted (re-throw bypasses it) 123 123 - expect(spy).not.toHaveBeenCalledWith( 129 129 + expect(mockLogger.error).not.toHaveBeenCalledWith( 124 130 "Failed to read resource", 125 131 expect.any(Object) 126 132 ); ··· 134 140 const app = makeApp((c) => 135 141 handleWriteError(c, new Error("fetch failed"), "Failed to create thing", { 136 142 operation: "POST /test", 143 143 + logger: createMockLogger(), 137 144 }) 138 145 ); 139 146 ··· 150 157 const app = makeApp((c) => 151 158 handleWriteError(c, new Error("database connection lost"), "Failed to create thing", { 152 159 operation: "POST /test", 160 160 + logger: createMockLogger(), 153 161 }) 154 162 ); 155 163 ··· 166 174 const app = makeApp((c) => 167 175 handleWriteError(c, new Error("Something unexpected"), "Failed to create thing", { 168 176 operation: "POST /test", 177 177 + logger: createMockLogger(), 169 178 }) 170 179 ); 171 180 ··· 177 186 }); 178 187 179 188 it("re-throws TypeError (programming error) and logs CRITICAL", async () => { 180 180 - const spy = vi.spyOn(console, "error").mockImplementation(() => {}); 189 189 + const mockLogger = createMockLogger(); 181 190 const programmingError = new TypeError("Cannot read property of null"); 182 191 const app = makeApp((c) => 183 192 handleWriteError(c, programmingError, "Failed to create thing", { 184 193 operation: "POST /test", 194 194 + logger: mockLogger, 185 195 }) 186 196 ); 187 197 188 198 const res = await app.request("/test", { method: "POST" }); 189 199 expect(res.status).toBe(500); 190 200 191 191 - expect(spy).toHaveBeenCalledWith( 201 201 + expect(mockLogger.error).toHaveBeenCalledWith( 192 202 "CRITICAL: Programming error in POST /test", 193 203 expect.objectContaining({ 194 204 operation: "POST /test", ··· 197 207 }) 198 208 ); 199 209 200 200 - expect(spy).not.toHaveBeenCalledWith( 210 210 + expect(mockLogger.error).not.toHaveBeenCalledWith( 201 211 "Failed to create thing", 202 212 expect.any(Object) 203 213 ); ··· 211 221 const app = makeApp((c) => 212 222 handleSecurityCheckError(c, new Error("fetch failed"), "Unable to verify access", { 213 223 operation: "POST /test - security check", 224 224 + logger: createMockLogger(), 214 225 }) 215 226 ); 216 227 ··· 227 238 const app = makeApp((c) => 228 239 handleSecurityCheckError(c, new Error("sql query failed"), "Unable to verify access", { 229 240 operation: "POST /test - security check", 241 241 + logger: createMockLogger(), 230 242 }) 231 243 ); 232 244 ··· 240 252 }); 241 253 242 254 it("returns 500 for unexpected errors (fail closed)", async () => { 243 243 - vi.spyOn(console, "error").mockImplementation(() => {}); 244 255 const app = makeApp((c) => 245 256 handleSecurityCheckError(c, new Error("Something unexpected"), "Unable to verify access", { 246 257 operation: "POST /test - security check", 258 258 + logger: createMockLogger(), 247 259 }) 248 260 ); 249 261 ··· 257 269 }); 258 270 259 271 it("re-throws TypeError (programming error) and logs CRITICAL", async () => { 260 260 - const spy = vi.spyOn(console, "error").mockImplementation(() => {}); 272 272 + const mockLogger = createMockLogger(); 261 273 const programmingError = new TypeError("Cannot read property of undefined"); 262 274 const app = makeApp((c) => 263 275 handleSecurityCheckError(c, programmingError, "Unable to verify access", { 264 276 operation: "POST /test - security check", 277 277 + logger: mockLogger, 265 278 }) 266 279 ); 267 280 268 281 const res = await app.request("/test", { method: "POST" }); 269 282 expect(res.status).toBe(500); 270 283 271 271 - expect(spy).toHaveBeenCalledWith( 284 284 + expect(mockLogger.error).toHaveBeenCalledWith( 272 285 "CRITICAL: Programming error in POST /test - security check", 273 286 expect.objectContaining({ 274 287 operation: "POST /test - security check", ··· 277 290 }) 278 291 ); 279 292 280 280 - expect(spy).not.toHaveBeenCalledWith( 293 293 + expect(mockLogger.error).not.toHaveBeenCalledWith( 281 294 "Unable to verify access", 282 295 expect.any(Object) 283 296 ); ··· 333 346 const appCtx = { 334 347 forumAgent: null, 335 348 config: { forumDid: "did:plc:forum" }, 349 349 + logger: createMockLogger(), 336 350 } as unknown as AppContext; 337 351 338 352 const app = new Hono(); ··· 353 367 const appCtx = { 354 368 forumAgent: { getAgent: () => null }, 355 369 config: { forumDid: "did:plc:forum" }, 370 370 + logger: createMockLogger(), 356 371 } as unknown as AppContext; 357 372 358 373 const app = new Hono(); ··· 374 389 const appCtx = { 375 390 forumAgent: { getAgent: () => mockAgent }, 376 391 config: { forumDid: "did:plc:forum" }, 392 392 + logger: createMockLogger(), 377 393 } as unknown as AppContext; 378 394 379 395 const app = new Hono();

+7 -12

apps/appview/src/lib/__tests__/session.test.ts

··· 1 1 import { describe, it, expect, vi, beforeEach } from "vitest"; 2 2 import { restoreOAuthSession } from "../session.js"; 3 3 + import { createMockLogger } from "./mock-logger.js"; 3 4 import type { AppContext } from "../app-context.js"; 4 5 5 6 /** ··· 31 32 return { 32 33 cookieSessionStore, 33 34 oauthClient, 35 35 + logger: createMockLogger(), 34 36 // Remaining fields are not used by restoreOAuthSession 35 37 config: {} as any, 36 38 db: {} as any, ··· 113 115 114 116 it("re-throws unexpected errors from OAuth restore", async () => { 115 117 const networkError = new Error("fetch failed: ECONNREFUSED"); 116 116 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 117 118 118 119 const ctx = createMockAppContext({ 119 120 cookieSession: { ··· 129 130 ); 130 131 131 132 // Verify the error was logged before re-throwing 132 132 - expect(consoleSpy).toHaveBeenCalledWith( 133 133 + expect(ctx.logger.error).toHaveBeenCalledWith( 133 134 "Unexpected error restoring OAuth session", 134 135 expect.objectContaining({ 135 136 operation: "restoreOAuthSession", ··· 137 138 error: "fetch failed: ECONNREFUSED", 138 139 }) 139 140 ); 140 140 - 141 141 - consoleSpy.mockRestore(); 142 141 }); 143 142 144 143 it("logs structured context when unexpected error occurs", async () => { 145 144 const dbError = new Error("Database connection lost"); 146 146 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 147 145 148 146 const ctx = createMockAppContext({ 149 147 cookieSession: { ··· 159 157 "Database connection lost" 160 158 ); 161 159 162 162 - expect(consoleSpy).toHaveBeenCalledWith( 160 160 + expect(ctx.logger.error).toHaveBeenCalledWith( 163 161 "Unexpected error restoring OAuth session", 164 162 { 165 163 operation: "restoreOAuthSession", ··· 167 165 error: "Database connection lost", 168 166 } 169 167 ); 170 170 - 171 171 - consoleSpy.mockRestore(); 172 168 }); 173 169 174 170 it("handles non-Error thrown values", async () => { 175 175 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 171 171 + const mockLogger = createMockLogger(); 176 172 177 173 const cookieSessionStore = { 178 174 get: vi.fn().mockReturnValue({ ··· 188 184 const ctx = { 189 185 cookieSessionStore, 190 186 oauthClient, 187 187 + logger: mockLogger, 191 188 config: {} as any, 192 189 db: {} as any, 193 190 firehose: {} as any, ··· 200 197 ); 201 198 202 199 // Non-Error values should be stringified in the log 203 203 - expect(consoleSpy).toHaveBeenCalledWith( 200 200 + expect(mockLogger.error).toHaveBeenCalledWith( 204 201 "Unexpected error restoring OAuth session", 205 202 expect.objectContaining({ 206 203 error: "string error", 207 204 }) 208 205 ); 209 209 - 210 210 - consoleSpy.mockRestore(); 211 206 }); 212 207 });

+8

apps/appview/src/lib/__tests__/test-context.ts

··· 3 3 import postgres from "postgres"; 4 4 import { forums, posts, users, categories, memberships, boards, roles, modActions, backfillProgress, backfillErrors } from "@atbb/db"; 5 5 import * as schema from "@atbb/db"; 6 6 + import { createLogger } from "@atbb/logger"; 6 7 import type { AppConfig } from "../config.js"; 7 8 import type { AppContext } from "../app-context.js"; 8 9 ··· 28 29 pdsUrl: "https://test.pds", 29 30 databaseUrl: process.env.DATABASE_URL ?? "", 30 31 jetstreamUrl: "wss://test.jetstream", 32 32 + logLevel: "warn", 31 33 oauthPublicUrl: "http://localhost:3000", 32 34 sessionSecret: "test-secret-at-least-32-characters-long", 33 35 sessionTtlDays: 7, ··· 84 86 }); 85 87 } 86 88 89 89 + const logger = createLogger({ 90 90 + service: "atbb-appview-test", 91 91 + level: "warn", 92 92 + }); 93 93 + 87 94 return { 88 95 db, 89 96 config, 97 97 + logger, 90 98 firehose: stubFirehose, 91 99 oauthClient: stubOAuthClient, 92 100 oauthStateStore: stubOAuthStateStore,

+29 -20

apps/appview/src/lib/__tests__/ttl-store.test.ts

··· 1 1 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; 2 2 import { TTLStore } from "../ttl-store.js"; 3 3 + import { createMockLogger } from "./mock-logger.js"; 3 4 4 5 describe("TTLStore", () => { 5 6 let store: TTLStore<{ value: string; createdAt: number }>; ··· 156 157 it("logs when expired entries are cleaned up", () => { 157 158 const ttlMs = 1000; 158 159 const cleanupIntervalMs = 5000; 159 159 - const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {}); 160 160 + const mockLogger = createMockLogger(); 160 161 161 161 - createStore(ttlMs, cleanupIntervalMs); 162 162 + store = new TTLStore<{ value: string; createdAt: number }>( 163 163 + (entry) => Date.now() - entry.createdAt > ttlMs, 164 164 + "test_store", 165 165 + cleanupIntervalMs, 166 166 + mockLogger, 167 167 + ); 162 168 store.set("key1", { value: "expired-1", createdAt: Date.now() }); 163 169 store.set("key2", { value: "expired-2", createdAt: Date.now() }); 164 170 165 171 // Advance past TTL + cleanup interval 166 172 vi.advanceTimersByTime(ttlMs + cleanupIntervalMs + 1); 167 173 168 168 - expect(infoSpy).toHaveBeenCalledWith( 174 174 + expect(mockLogger.info).toHaveBeenCalledWith( 169 175 "test_store cleanup completed", 170 176 expect.objectContaining({ 171 177 operation: "test_store.cleanup", ··· 173 179 remainingCount: 0, 174 180 }) 175 181 ); 176 176 - 177 177 - infoSpy.mockRestore(); 178 182 }); 179 183 180 184 it("does not log when no entries are expired", () => { 181 185 const ttlMs = 60_000; 182 186 const cleanupIntervalMs = 5000; 183 183 - const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {}); 187 187 + const mockLogger = createMockLogger(); 184 188 185 185 - createStore(ttlMs, cleanupIntervalMs); 189 189 + store = new TTLStore<{ value: string; createdAt: number }>( 190 190 + (entry) => Date.now() - entry.createdAt > ttlMs, 191 191 + "test_store", 192 192 + cleanupIntervalMs, 193 193 + mockLogger, 194 194 + ); 186 195 store.set("key1", { value: "still-fresh", createdAt: Date.now() }); 187 196 188 197 // Advance to trigger cleanup, but entries are not expired 189 198 vi.advanceTimersByTime(cleanupIntervalMs + 1); 190 199 191 191 - expect(infoSpy).not.toHaveBeenCalled(); 192 192 - 193 193 - infoSpy.mockRestore(); 200 200 + expect(mockLogger.info).not.toHaveBeenCalled(); 194 201 }); 195 202 196 203 it("keeps non-expired entries during cleanup", () => { ··· 212 219 213 220 it("handles cleanup errors gracefully", () => { 214 221 const cleanupIntervalMs = 5000; 215 215 - const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 222 222 + const mockLogger = createMockLogger(); 216 223 217 224 // Create a store with an isExpired that throws 218 225 store = new TTLStore<{ value: string; createdAt: number }>( ··· 220 227 throw new Error("expiration check failed"); 221 228 }, 222 229 "error_store", 223 223 - cleanupIntervalMs 230 230 + cleanupIntervalMs, 231 231 + mockLogger, 224 232 ); 225 233 226 234 store.set("key1", { value: "test", createdAt: Date.now() }); ··· 228 236 // Trigger cleanup - should not throw 229 237 vi.advanceTimersByTime(cleanupIntervalMs + 1); 230 238 231 231 - expect(errorSpy).toHaveBeenCalledWith( 239 239 + expect(mockLogger.error).toHaveBeenCalledWith( 232 240 "error_store cleanup failed", 233 241 expect.objectContaining({ 234 242 operation: "error_store.cleanup", 235 243 error: "expiration check failed", 236 244 }) 237 245 ); 238 238 - 239 239 - errorSpy.mockRestore(); 240 246 }); 241 247 }); 242 248 ··· 244 250 it("stops the cleanup interval", () => { 245 251 const ttlMs = 1000; 246 252 const cleanupIntervalMs = 5000; 247 247 - const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {}); 253 253 + const mockLogger = createMockLogger(); 248 254 249 249 - createStore(ttlMs, cleanupIntervalMs); 255 255 + store = new TTLStore<{ value: string; createdAt: number }>( 256 256 + (entry) => Date.now() - entry.createdAt > ttlMs, 257 257 + "test_store", 258 258 + cleanupIntervalMs, 259 259 + mockLogger, 260 260 + ); 250 261 store.set("key1", { value: "expired", createdAt: Date.now() }); 251 262 252 263 // Advance past TTL ··· 259 270 vi.advanceTimersByTime(cleanupIntervalMs + 1); 260 271 261 272 // Cleanup should NOT have run (no log message) 262 262 - expect(infoSpy).not.toHaveBeenCalled(); 263 263 - 264 264 - infoSpy.mockRestore(); 273 273 + expect(mockLogger.info).not.toHaveBeenCalled(); 265 274 }); 266 275 }); 267 276

+21 -13

apps/appview/src/lib/app-context.ts

··· 1 1 import type { Database } from "@atbb/db"; 2 2 import { createDb } from "@atbb/db"; 3 3 + import type { Logger } from "@atbb/logger"; 4 4 + import { createLogger } from "@atbb/logger"; 3 5 import { FirehoseService } from "./firehose.js"; 4 6 import { NodeOAuthClient } from "@atproto/oauth-client-node"; 5 7 import { OAuthStateStore, OAuthSessionStore } from "./oauth-stores.js"; ··· 14 16 */ 15 17 export interface AppContext { 16 18 config: AppConfig; 19 19 + logger: Logger; 17 20 db: Database; 18 21 firehose: FirehoseService; 19 22 oauthClient: NodeOAuthClient; ··· 29 32 * This is the composition root where we wire up all dependencies. 30 33 */ 31 34 export async function createAppContext(config: AppConfig): Promise<AppContext> { 35 35 + const logger = createLogger({ 36 36 + service: "atbb-appview", 37 37 + version: "0.1.0", 38 38 + environment: process.env.NODE_ENV ?? "development", 39 39 + level: config.logLevel, 40 40 + }); 41 41 + 32 42 const db = createDb(config.databaseUrl); 33 33 - const firehose = new FirehoseService(db, config.jetstreamUrl); 43 43 + const firehose = new FirehoseService(db, config.jetstreamUrl, logger); 34 44 35 45 // Initialize OAuth stores 36 46 const oauthStateStore = new OAuthStateStore(); ··· 88 98 forumAgent = new ForumAgent( 89 99 config.pdsUrl, 90 100 config.forumHandle, 91 91 - config.forumPassword 101 101 + config.forumPassword, 102 102 + logger 92 103 ); 93 104 await forumAgent.initialize(); 94 105 } else { 95 95 - console.warn( 96 96 - JSON.stringify({ 97 97 - event: "forumAgent.credentialsMissing", 98 98 - service: "AppContext", 99 99 - operation: "createAppContext", 100 100 - reason: "Missing FORUM_HANDLE or FORUM_PASSWORD environment variables", 101 101 - timestamp: new Date().toISOString(), 102 102 - }) 103 103 - ); 106 106 + logger.warn("ForumAgent credentials missing", { 107 107 + operation: "createAppContext", 108 108 + reason: "Missing FORUM_HANDLE or FORUM_PASSWORD environment variables", 109 109 + }); 104 110 } 105 111 106 112 return { 107 113 config, 114 114 + logger, 108 115 db, 109 116 firehose, 110 117 oauthClient, ··· 112 119 oauthSessionStore, 113 120 cookieSessionStore, 114 121 forumAgent, 115 115 - backfillManager: new BackfillManager(db, config), 122 122 + backfillManager: new BackfillManager(db, config, logger), 116 123 }; 117 124 } 118 125 ··· 131 138 ctx.oauthSessionStore.destroy(); 132 139 ctx.cookieSessionStore.destroy(); 133 140 134 134 - // Future: close database connection when needed 141 141 + // Flush pending log records and release OTel resources 142 142 + await ctx.logger.shutdown(); 135 143 }

+7 -3

apps/appview/src/lib/at-uri.ts

··· 1 1 + import type { Logger } from "@atbb/logger"; 2 2 + 1 3 /** 2 4 * Parsed components of an AT Protocol URI. 3 5 * Format: at://did:plc:xxx/collection.name/rkey ··· 12 14 * Parse an AT Protocol URI into its component parts. 13 15 * 14 16 * @param uri - AT-URI like "at://did:plc:abc/space.atbb.post/3lbk7xxx" 17 17 + * @param logger - Optional structured logger for warnings/errors 15 18 * @returns Parsed components, or null if the URI is invalid 16 19 */ 17 17 - export function parseAtUri(uri: string): ParsedAtUri | null { 20 20 + export function parseAtUri(uri: string, logger?: Logger): ParsedAtUri | null { 18 21 try { 19 22 const match = uri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/); 20 23 if (!match) { 21 21 - console.warn(`Invalid AT URI format: ${uri}`); 24 24 + logger?.warn("Invalid AT URI format", { uri }); 22 25 return null; 23 26 } 24 27 25 28 const [, did, collection, rkey] = match; 26 29 return { did, collection, rkey }; 27 30 } catch (error) { 28 28 - console.error(`Unexpected error parsing AT URI: ${uri}`, { 31 31 + logger?.error("Unexpected error parsing AT URI", { 32 32 + uri, 29 33 error: error instanceof Error ? error.message : String(error), 30 34 }); 31 35 return null;

+49 -66

apps/appview/src/lib/backfill-manager.ts

··· 6 6 import type { AppConfig } from "./config.js"; 7 7 import type { Indexer } from "./indexer.js"; 8 8 import { isProgrammingError } from "./errors.js"; 9 9 + import type { Logger } from "@atbb/logger"; 9 10 10 11 /** 11 12 * Maps AT Proto collection NSIDs to Indexer handler method names. ··· 64 65 constructor( 65 66 private db: Database, 66 67 private config: AppConfig, 68 68 + private logger: Logger, 67 69 ) { 68 68 - this.cursorManager = new CursorManager(db); 70 70 + this.cursorManager = new CursorManager(db, logger); 69 71 } 70 72 71 73 /** ··· 88 90 const handlerName = COLLECTION_HANDLER_MAP[collection]; 89 91 90 92 if (!handlerName || !this.indexer) { 91 91 - console.error(JSON.stringify({ 93 93 + this.logger.error("backfill.sync_skipped", { 92 94 event: "backfill.sync_skipped", 93 95 did, 94 96 collection, 95 97 reason: !handlerName ? "unknown_collection" : "indexer_not_set", 96 96 - timestamp: new Date().toISOString(), 97 97 - })); 98 98 + }); 98 99 stats.errors = 1; 99 100 return stats; 100 101 } ··· 127 128 } catch (error) { 128 129 if (isProgrammingError(error)) throw error; 129 130 stats.errors++; 130 130 - console.error(JSON.stringify({ 131 131 + this.logger.error("backfill.record_error", { 131 132 event: "backfill.record_error", 132 133 did, 133 134 collection, 134 135 uri: record.uri, 135 136 error: error instanceof Error ? error.message : String(error), 136 136 - timestamp: new Date().toISOString(), 137 137 - })); 137 137 + }); 138 138 } 139 139 } 140 140 ··· 147 147 } while (cursor); 148 148 } catch (error) { 149 149 stats.errors++; 150 150 - console.error(JSON.stringify({ 150 150 + this.logger.error("backfill.pds_error", { 151 151 event: "backfill.pds_error", 152 152 did, 153 153 collection, 154 154 error: error instanceof Error ? error.message : String(error), 155 155 - timestamp: new Date().toISOString(), 156 156 - })); 155 155 + }); 157 156 } 158 157 159 158 return stats; ··· 165 164 async checkIfNeeded(cursor: bigint | null): Promise<BackfillStatus> { 166 165 // No cursor at all → first startup or wiped cursor 167 166 if (cursor === null) { 168 168 - console.log(JSON.stringify({ 167 167 + this.logger.info("backfill.decision", { 169 168 event: "backfill.decision", 170 169 status: BackfillStatus.FullSync, 171 170 reason: "no_cursor", 172 172 - timestamp: new Date().toISOString(), 173 173 - })); 171 171 + }); 174 172 return BackfillStatus.FullSync; 175 173 } 176 174 ··· 184 182 .limit(1); 185 183 forum = results[0]; 186 184 } catch (error) { 187 187 - console.error(JSON.stringify({ 185 185 + this.logger.error("backfill.decision", { 188 186 event: "backfill.decision", 189 187 status: BackfillStatus.FullSync, 190 188 reason: "db_query_failed", 191 189 error: error instanceof Error ? error.message : String(error), 192 192 - timestamp: new Date().toISOString(), 193 193 - })); 190 190 + }); 194 191 return BackfillStatus.FullSync; 195 192 } 196 193 197 194 if (!forum) { 198 198 - console.log(JSON.stringify({ 195 195 + this.logger.info("backfill.decision", { 199 196 event: "backfill.decision", 200 197 status: BackfillStatus.FullSync, 201 198 reason: "db_inconsistency", 202 199 cursorTimestamp: cursor.toString(), 203 203 - timestamp: new Date().toISOString(), 204 204 - })); 200 200 + }); 205 201 return BackfillStatus.FullSync; 206 202 } 207 203 208 204 // Check cursor age 209 205 const ageHours = this.cursorManager.getCursorAgeHours(cursor)!; 210 206 if (ageHours > this.config.backfillCursorMaxAgeHours) { 211 211 - console.log(JSON.stringify({ 207 207 + this.logger.info("backfill.decision", { 212 208 event: "backfill.decision", 213 209 status: BackfillStatus.CatchUp, 214 210 reason: "cursor_too_old", 215 211 cursorAgeHours: Math.round(ageHours), 216 212 thresholdHours: this.config.backfillCursorMaxAgeHours, 217 213 cursorTimestamp: cursor.toString(), 218 218 - timestamp: new Date().toISOString(), 219 219 - })); 214 214 + }); 220 215 return BackfillStatus.CatchUp; 221 216 } 222 217 223 223 - console.log(JSON.stringify({ 218 218 + this.logger.info("backfill.decision", { 224 219 event: "backfill.decision", 225 220 status: BackfillStatus.NotNeeded, 226 221 reason: "cursor_fresh", 227 222 cursorAgeHours: Math.round(ageHours), 228 228 - timestamp: new Date().toISOString(), 229 229 - })); 223 223 + }); 230 224 return BackfillStatus.NotNeeded; 231 225 } 232 226 ··· 277 271 return row ?? null; 278 272 } catch (error) { 279 273 if (isProgrammingError(error)) throw error; 280 280 - console.error(JSON.stringify({ 274 274 + this.logger.error("backfill.check_interrupted.failed", { 281 275 event: "backfill.check_interrupted.failed", 282 276 error: error instanceof Error ? error.message : String(error), 283 277 note: "Could not check for interrupted backfills — assuming none", 284 284 - timestamp: new Date().toISOString(), 285 285 - })); 278 278 + }); 286 279 return null; 287 280 } 288 281 } ··· 303 296 let totalErrors = 0; 304 297 let didsProcessed = interrupted.didsProcessed; 305 298 306 306 - console.log(JSON.stringify({ 299 299 + this.logger.info("backfill.resuming", { 307 300 event: "backfill.resuming", 308 301 backfillId: interrupted.id.toString(), 309 302 lastProcessedDid: interrupted.lastProcessedDid, 310 303 didsProcessed: interrupted.didsProcessed, 311 304 didsTotal: interrupted.didsTotal, 312 312 - timestamp: new Date().toISOString(), 313 313 - })); 305 305 + }); 314 306 315 307 try { 316 308 const agent = this.createAgentForPds(); ··· 364 356 totalErrors += result.value.errors; 365 357 } else { 366 358 totalErrors++; 367 367 - console.error(JSON.stringify({ 359 359 + this.logger.error("backfill.resume.batch_user_failed", { 368 360 event: "backfill.resume.batch_user_failed", 369 361 backfillId: backfillId.toString(), 370 362 did: batch[i].did, 371 363 error: result.reason instanceof Error ? result.reason.message : String(result.reason), 372 372 - timestamp: new Date().toISOString(), 373 373 - })); 364 364 + }); 374 365 } 375 366 }); 376 367 ··· 387 378 .where(eq(backfillProgress.id, backfillId)); 388 379 } catch (checkpointError) { 389 380 if (isProgrammingError(checkpointError)) throw checkpointError; 390 390 - console.warn(JSON.stringify({ 381 381 + this.logger.warn("backfill.resume.checkpoint_failed", { 391 382 event: "backfill.resume.checkpoint_failed", 392 383 backfillId: backfillId.toString(), 393 384 didsProcessed, 394 385 error: checkpointError instanceof Error ? checkpointError.message : String(checkpointError), 395 386 note: "Checkpoint save failed — continuing backfill. Resume may reprocess this batch.", 396 396 - timestamp: new Date().toISOString(), 397 397 - })); 387 387 + }); 398 388 } 399 389 } 400 390 } ··· 419 409 durationMs: Date.now() - startTime, 420 410 }; 421 411 422 422 - console.log(JSON.stringify({ 423 423 - event: totalErrors > 0 ? "backfill.resume.completed_with_errors" : "backfill.resume.completed", 412 412 + const resumeEvent = totalErrors > 0 ? "backfill.resume.completed_with_errors" : "backfill.resume.completed"; 413 413 + this.logger.info(resumeEvent, { 414 414 + event: resumeEvent, 424 415 ...result, 425 416 backfillId: result.backfillId.toString(), 426 426 - timestamp: new Date().toISOString(), 427 427 - })); 417 417 + }); 428 418 429 419 return result; 430 420 } catch (error) { ··· 439 429 }) 440 430 .where(eq(backfillProgress.id, interrupted.id)); 441 431 } catch (updateError) { 442 442 - console.error(JSON.stringify({ 432 432 + this.logger.error("backfill.resume.failed_status_update_error", { 443 433 event: "backfill.resume.failed_status_update_error", 444 434 backfillId: interrupted.id.toString(), 445 435 error: updateError instanceof Error ? updateError.message : String(updateError), 446 446 - timestamp: new Date().toISOString(), 447 447 - })); 436 436 + }); 448 437 } 449 438 450 450 - console.error(JSON.stringify({ 439 439 + this.logger.error("backfill.resume.failed", { 451 440 event: "backfill.resume.failed", 452 441 backfillId: interrupted.id.toString(), 453 442 error: error instanceof Error ? error.message : String(error), 454 454 - timestamp: new Date().toISOString(), 455 455 - })); 443 443 + }); 456 444 throw error; 457 445 } finally { 458 446 this.isRunning = false; ··· 564 552 totalErrors += result.value.errors; 565 553 } else { 566 554 totalErrors++; 567 567 - console.error(JSON.stringify({ 555 555 + this.logger.error("backfill.batch_user_failed", { 568 556 event: "backfill.batch_user_failed", 569 557 backfillId: resolvedBackfillId.toString(), 570 558 did: batch[i].did, 571 559 error: result.reason instanceof Error ? result.reason.message : String(result.reason), 572 572 - timestamp: new Date().toISOString(), 573 573 - })); 560 560 + }); 574 561 } 575 562 }); 576 563 ··· 587 574 .where(eq(backfillProgress.id, backfillId)); 588 575 } catch (checkpointError) { 589 576 if (isProgrammingError(checkpointError)) throw checkpointError; 590 590 - console.warn(JSON.stringify({ 577 577 + this.logger.warn("backfill.checkpoint_failed", { 591 578 event: "backfill.checkpoint_failed", 592 579 backfillId: resolvedBackfillId.toString(), 593 580 didsProcessed, 594 581 error: checkpointError instanceof Error ? checkpointError.message : String(checkpointError), 595 582 note: "Checkpoint save failed — continuing backfill. Resume may reprocess this batch.", 596 596 - timestamp: new Date().toISOString(), 597 597 - })); 583 583 + }); 598 584 } 599 585 600 600 - console.log(JSON.stringify({ 586 586 + this.logger.info("backfill.progress", { 601 587 event: "backfill.progress", 602 588 backfillId: backfillId.toString(), 603 589 type, ··· 605 591 didsTotal, 606 592 recordsIndexed: totalIndexed, 607 593 elapsedMs: Date.now() - startTime, 608 608 - timestamp: new Date().toISOString(), 609 609 - })); 594 594 + }); 610 595 } 611 596 } 612 597 ··· 630 615 durationMs: Date.now() - startTime, 631 616 }; 632 617 633 633 - console.log(JSON.stringify({ 634 634 - event: totalErrors > 0 ? "backfill.completed_with_errors" : "backfill.completed", 618 618 + const completedEvent = totalErrors > 0 ? "backfill.completed_with_errors" : "backfill.completed"; 619 619 + this.logger.info(completedEvent, { 620 620 + event: completedEvent, 635 621 ...result, 636 622 backfillId: result.backfillId.toString(), 637 637 - timestamp: new Date().toISOString(), 638 638 - })); 623 623 + }); 639 624 640 625 return result; 641 626 } catch (error) { ··· 651 636 }) 652 637 .where(eq(backfillProgress.id, backfillId)); 653 638 } catch (updateError) { 654 654 - console.error(JSON.stringify({ 639 639 + this.logger.error("backfill.failed_status_update_error", { 655 640 event: "backfill.failed_status_update_error", 656 641 backfillId: backfillId.toString(), 657 642 error: updateError instanceof Error ? updateError.message : String(updateError), 658 658 - timestamp: new Date().toISOString(), 659 659 - })); 643 643 + }); 660 644 } 661 645 } 662 646 663 663 - console.error(JSON.stringify({ 647 647 + this.logger.error("backfill.failed", { 664 648 event: "backfill.failed", 665 649 backfillId: backfillId !== undefined ? backfillId.toString() : "not_created", 666 650 error: error instanceof Error ? error.message : String(error), 667 667 - timestamp: new Date().toISOString(), 668 668 - })); 651 651 + }); 669 652 throw error; 670 653 } finally { 671 654 this.isRunning = false;

+7 -6

apps/appview/src/lib/ban-enforcer.ts

··· 1 1 import type { DbOrTransaction } from "@atbb/db"; 2 2 import { modActions, posts } from "@atbb/db"; 3 3 + import type { Logger } from "@atbb/logger"; 3 4 import { and, eq, gt, isNull, or } from "drizzle-orm"; 4 5 import { isProgrammingError } from "./errors.js"; 5 6 ··· 12 13 * - Restore posts when a ban is lifted 13 14 */ 14 15 export class BanEnforcer { 15 15 - constructor(private db: DbOrTransaction) {} 16 16 + constructor(private db: DbOrTransaction, private logger: Logger) {} 16 17 17 18 /** 18 19 * Returns true if the DID has an active (non-expired) ban. ··· 36 37 return result.length > 0; 37 38 } catch (error) { 38 39 if (isProgrammingError(error)) throw error; 39 39 - console.error( 40 40 + this.logger.error( 40 41 "Failed to check ban status - denying indexing (fail closed)", 41 42 { 42 43 did, ··· 57 58 .update(posts) 58 59 .set({ deleted: true }) 59 60 .where(eq(posts.did, subjectDid)); 60 60 - console.log("[BAN] Applied ban: soft-deleted all posts", { subjectDid }); 61 61 + this.logger.info("Applied ban: soft-deleted all posts", { subjectDid }); 61 62 } catch (error) { 62 62 - console.error("Failed to apply ban - posts may not be hidden", { 63 63 + this.logger.error("Failed to apply ban - posts may not be hidden", { 63 64 subjectDid, 64 65 error: error instanceof Error ? error.message : String(error), 65 66 }); ··· 83 84 .update(posts) 84 85 .set({ deleted: false }) 85 86 .where(eq(posts.did, subjectDid)); 86 86 - console.log("[UNBAN] Lifted ban: restored all posts", { subjectDid }); 87 87 + this.logger.info("Lifted ban: restored all posts", { subjectDid }); 87 88 } catch (error) { 88 88 - console.error("Failed to lift ban - posts may not be restored", { 89 89 + this.logger.error("Failed to lift ban - posts may not be restored", { 89 90 subjectDid, 90 91 error: error instanceof Error ? error.message : String(error), 91 92 });

+13 -8

apps/appview/src/lib/circuit-breaker.ts

··· 1 1 + import type { Logger } from "@atbb/logger"; 2 2 + 1 3 /** 2 4 * Implements circuit breaker pattern to prevent cascading failures. 3 5 * ··· 14 16 */ 15 17 constructor( 16 18 private maxFailures: number, 17 17 - private onBreak: () => Promise<void> 19 19 + private onBreak: () => Promise<void>, 20 20 + private logger: Logger 18 21 ) {} 19 22 20 23 /** ··· 40 43 */ 41 44 private async recordFailure(operationName: string, error: unknown): Promise<void> { 42 45 this.consecutiveFailures++; 43 43 - console.error( 44 44 - `[CIRCUIT BREAKER] ${operationName} failed (${this.consecutiveFailures}/${this.maxFailures}):`, 45 45 - error 46 46 - ); 46 46 + this.logger.error("Circuit breaker failure", { 47 47 + operationName, 48 48 + consecutiveFailures: this.consecutiveFailures, 49 49 + maxFailures: this.maxFailures, 50 50 + error: error instanceof Error ? error.message : String(error), 51 51 + }); 47 52 48 53 if (this.consecutiveFailures >= this.maxFailures) { 49 49 - console.error( 50 50 - `[CIRCUIT BREAKER] Max consecutive failures (${this.maxFailures}) reached.` 51 51 - ); 54 54 + this.logger.error("Circuit breaker tripped - max consecutive failures reached", { 55 55 + maxFailures: this.maxFailures, 56 56 + }); 52 57 await this.onBreak(); 53 58 } 54 59 }

+19

apps/appview/src/lib/config.ts

··· 1 1 + import type { LogLevel } from "@atbb/logger"; 2 2 + 1 3 export interface AppConfig { 2 4 port: number; 3 5 forumDid: string; 4 6 pdsUrl: string; 5 7 databaseUrl: string; 6 8 jetstreamUrl: string; 9 9 + // Logging 10 10 + logLevel: LogLevel; 7 11 // OAuth configuration 8 12 oauthPublicUrl: string; 9 13 sessionSecret: string; ··· 27 31 jetstreamUrl: 28 32 process.env.JETSTREAM_URL ?? 29 33 "wss://jetstream2.us-east.bsky.network/subscribe", 34 34 + // Logging 35 35 + logLevel: parseLogLevel(process.env.LOG_LEVEL), 30 36 // OAuth configuration 31 37 oauthPublicUrl: process.env.OAUTH_PUBLIC_URL ?? `http://localhost:${process.env.PORT ?? "3000"}`, 32 38 sessionSecret: process.env.SESSION_SECRET ?? "", ··· 44 50 validateOAuthConfig(config); 45 51 46 52 return config; 53 53 + } 54 54 + 55 55 + const LOG_LEVELS: readonly LogLevel[] = ["debug", "info", "warn", "error", "fatal"]; 56 56 + 57 57 + function parseLogLevel(value: string | undefined): LogLevel { 58 58 + if (value !== undefined && !(LOG_LEVELS as readonly string[]).includes(value)) { 59 59 + console.warn( 60 60 + `Invalid LOG_LEVEL "${value}". Must be one of: ${LOG_LEVELS.join(", ")}. Defaulting to "info".` 61 61 + ); 62 62 + } 63 63 + return (LOG_LEVELS as readonly string[]).includes(value ?? "") 64 64 + ? (value as LogLevel) 65 65 + : "info"; 47 66 } 48 67 49 68 /**

+3 -3

apps/appview/src/lib/create-app.ts

··· 1 1 import { Hono } from "hono"; 2 2 - import { logger } from "hono/logger"; 2 2 + import { requestLogger } from "@atbb/logger/middleware"; 3 3 import { createApiRoutes } from "../routes/index.js"; 4 4 import type { AppContext } from "./app-context.js"; 5 5 ··· 10 10 export function createApp(ctx: AppContext) { 11 11 const app = new Hono(); 12 12 13 13 - app.use("*", logger()); 13 13 + app.use("*", requestLogger(ctx.logger)); 14 14 15 15 // Global error handler for unhandled errors 16 16 app.onError((err, c) => { 17 17 - console.error("Unhandled error in route handler", { 17 17 + ctx.logger.error("Unhandled error in route handler", { 18 18 path: c.req.path, 19 19 method: c.req.method, 20 20 error: err.message,

+8 -3

apps/appview/src/lib/cursor-manager.ts

··· 1 1 import { type Database, firehoseCursor } from "@atbb/db"; 2 2 + import type { Logger } from "@atbb/logger"; 2 3 import { eq } from "drizzle-orm"; 3 4 4 5 /** ··· 8 9 * to enable resumption after restart or reconnection. 9 10 */ 10 11 export class CursorManager { 11 11 - constructor(private db: Database) {} 12 12 + constructor(private db: Database, private logger: Logger) {} 12 13 13 14 /** 14 15 * Load the last cursor from database ··· 26 27 27 28 return result.length > 0 ? result[0].cursor : null; 28 29 } catch (error) { 29 29 - console.error("Failed to load cursor from database:", error); 30 30 + this.logger.error("Failed to load cursor from database", { 31 31 + error: error instanceof Error ? error.message : String(error), 32 32 + }); 30 33 return null; 31 34 } 32 35 } ··· 55 58 }); 56 59 } catch (error) { 57 60 // Don't throw - we don't want cursor updates to break the stream 58 58 - console.error("Failed to update cursor:", error); 61 61 + this.logger.error("Failed to update cursor", { 62 62 + error: error instanceof Error ? error.message : String(error), 63 63 + }); 59 64 } 60 65 } 61 66

+27 -33

apps/appview/src/lib/firehose.ts

··· 1 1 import { Jetstream } from "@skyware/jetstream"; 2 2 import { type Database } from "@atbb/db"; 3 3 + import type { Logger } from "@atbb/logger"; 3 4 import { Indexer } from "./indexer.js"; 4 5 import { CursorManager } from "./cursor-manager.js"; 5 6 import { CircuitBreaker } from "./circuit-breaker.js"; ··· 44 45 45 46 constructor( 46 47 private db: Database, 47 47 - private jetstreamUrl: string 48 48 + private jetstreamUrl: string, 49 49 + private logger: Logger 48 50 ) { 49 51 // Initialize the indexer instance with the database 50 50 - this.indexer = new Indexer(db); 52 52 + this.indexer = new Indexer(db, logger); 51 53 52 54 // Initialize helper classes 53 53 - this.cursorManager = new CursorManager(db); 54 54 - this.circuitBreaker = new CircuitBreaker(100, () => this.stop()); 55 55 - this.reconnectionManager = new ReconnectionManager(10, 5000); 55 55 + this.cursorManager = new CursorManager(db, logger); 56 56 + this.circuitBreaker = new CircuitBreaker(100, () => this.stop(), logger); 57 57 + this.reconnectionManager = new ReconnectionManager(10, 5000, logger); 56 58 57 59 // Build handler registry 58 60 this.handlerRegistry = this.createHandlerRegistry(); ··· 157 159 158 160 // Handle errors and disconnections 159 161 this.jetstream.on("error", (error) => { 160 160 - console.error("Jetstream error:", error); 162 162 + this.logger.error("Jetstream error", { error: error instanceof Error ? error.message : String(error) }); 161 163 this.handleReconnect(); 162 164 }); 163 165 } ··· 167 169 */ 168 170 async start() { 169 171 if (this.running) { 170 170 - console.warn("Firehose service is already running"); 172 172 + this.logger.warn("Firehose service is already running"); 171 173 return; 172 174 } 173 175 ··· 181 183 try { 182 184 const interrupted = await this.backfillManager.checkForInterruptedBackfill(); 183 185 if (interrupted) { 184 184 - console.log(JSON.stringify({ 186 186 + this.logger.info("Resuming interrupted backfill", { 185 187 event: "firehose.backfill.resuming_interrupted", 186 188 backfillId: interrupted.id.toString(), 187 189 lastProcessedDid: interrupted.lastProcessedDid, 188 188 - timestamp: new Date().toISOString(), 189 189 - })); 190 190 + }); 190 191 await this.backfillManager.resumeBackfill(interrupted); 191 191 - console.log(JSON.stringify({ 192 192 + this.logger.info("Interrupted backfill resumed", { 192 193 event: "firehose.backfill.resumed", 193 194 backfillId: interrupted.id.toString(), 194 194 - timestamp: new Date().toISOString(), 195 195 - })); 195 195 + }); 196 196 } else { 197 197 const savedCursorForCheck = await this.cursorManager.load(); 198 198 const backfillStatus = await this.backfillManager.checkIfNeeded(savedCursorForCheck); 199 199 200 200 if (backfillStatus !== BackfillStatus.NotNeeded) { 201 201 - console.log(JSON.stringify({ 201 201 + this.logger.info("Starting backfill", { 202 202 event: "firehose.backfill.starting", 203 203 type: backfillStatus, 204 204 - timestamp: new Date().toISOString(), 205 205 - })); 204 204 + }); 206 205 await this.backfillManager.performBackfill(backfillStatus); 207 207 - console.log(JSON.stringify({ 206 206 + this.logger.info("Backfill completed", { 208 207 event: "firehose.backfill.completed", 209 208 type: backfillStatus, 210 210 - timestamp: new Date().toISOString(), 211 211 - })); 209 209 + }); 212 210 } 213 211 } 214 212 } catch (error) { 215 215 - console.error(JSON.stringify({ 213 213 + this.logger.error("Backfill skipped due to startup error — firehose will start without it", { 216 214 event: "firehose.backfill.startup_error", 217 215 error: error instanceof Error ? error.message : String(error), 218 218 - note: "Backfill skipped — firehose will start without it", 219 219 - timestamp: new Date().toISOString(), 220 220 - })); 216 216 + }); 221 217 // Continue to start firehose — stale data is better than no data 222 218 } 223 219 } ··· 226 222 // Load the last cursor from database 227 223 const savedCursor = await this.cursorManager.load(); 228 224 if (savedCursor) { 229 229 - console.log(`Resuming from cursor: ${savedCursor}`); 225 225 + this.logger.info("Resuming from cursor", { cursor: savedCursor.toString() }); 230 226 // Rewind by 10 seconds to ensure we don't miss any events 231 227 const rewindedCursor = this.cursorManager.rewind(savedCursor, 10_000_000); 232 228 ··· 235 231 this.setupEventHandlers(); 236 232 } 237 233 238 238 - console.log(`Starting Jetstream firehose subscription to ${this.jetstreamUrl}`); 234 234 + this.logger.info("Starting Jetstream firehose subscription", { url: this.jetstreamUrl }); 239 235 await this.jetstream.start(); 240 236 this.running = true; 241 237 this.reconnectionManager.reset(); 242 242 - console.log("Jetstream firehose subscription started successfully"); 238 238 + this.logger.info("Jetstream firehose subscription started successfully"); 243 239 } catch (error) { 244 244 - console.error("Failed to start Jetstream firehose:", error); 240 240 + this.logger.error("Failed to start Jetstream firehose", { error: error instanceof Error ? error.message : String(error) }); 245 241 this.handleReconnect(); 246 242 } 247 243 } ··· 254 250 return; 255 251 } 256 252 257 257 - console.log("Stopping Jetstream firehose subscription"); 253 253 + this.logger.info("Stopping Jetstream firehose subscription"); 258 254 await this.jetstream.close(); 259 255 this.running = false; 260 260 - console.log("Jetstream firehose subscription stopped"); 256 256 + this.logger.info("Jetstream firehose subscription stopped"); 261 257 } 262 258 263 259 /** ··· 298 294 await this.start(); 299 295 }); 300 296 } catch (error) { 301 301 - console.error(JSON.stringify({ 297 297 + this.logger.fatal("Firehose indexing has stopped. The appview will continue serving stale data.", { 302 298 event: "firehose.reconnect.exhausted", 303 299 error: error instanceof Error ? error.message : String(error), 304 304 - note: "Firehose indexing has stopped. AppView will continue serving stale data.", 305 305 - timestamp: new Date().toISOString(), 306 306 - })); 300 300 + }); 307 301 this.running = false; 308 302 } 309 303 }

+109 -84

apps/appview/src/lib/indexer.ts

··· 4 4 CommitUpdateEvent, 5 5 } from "@skyware/jetstream"; 6 6 import type { Database, DbOrTransaction } from "@atbb/db"; 7 7 + import type { Logger } from "@atbb/logger"; 7 8 import { 8 9 posts, 9 10 forums, ··· 71 72 export class Indexer { 72 73 private banEnforcer: BanEnforcer; 73 74 74 74 - constructor(private db: Database) { 75 75 - this.banEnforcer = new BanEnforcer(db); 75 75 + constructor(private db: Database, private logger: Logger) { 76 76 + this.banEnforcer = new BanEnforcer(db, logger); 76 77 } 77 78 78 79 // ── Collection Configs ────────────────────────────────── ··· 97 98 if (record.board?.board.uri) { 98 99 boardId = await this.getBoardIdByUri(record.board.board.uri, tx); 99 100 if (!boardId) { 100 100 - console.error("Failed to index post: board not found", { 101 101 + this.logger.error("Failed to index post: board not found", { 101 102 operation: "Post CREATE", 102 103 postDid: event.did, 103 104 postRkey: event.commit.rkey, ··· 131 132 if (record.board?.board.uri) { 132 133 boardId = await this.getBoardIdByUri(record.board.board.uri, tx); 133 134 if (!boardId) { 134 134 - console.error("Failed to index post: board not found", { 135 135 + this.logger.error("Failed to index post: board not found", { 135 136 operation: "Post UPDATE", 136 137 postDid: event.did, 137 138 postRkey: event.commit.rkey, ··· 184 185 const forumId = await this.getForumIdByDid(event.did, tx); 185 186 186 187 if (!forumId) { 187 187 - console.warn( 188 188 - `[CREATE] Category: Forum not found for DID ${event.did}` 189 189 - ); 188 188 + this.logger.warn("Category: Forum not found for DID", { 189 189 + operation: "Category CREATE", 190 190 + did: event.did, 191 191 + }); 190 192 return null; 191 193 } 192 194 ··· 208 210 const forumId = await this.getForumIdByDid(event.did, tx); 209 211 210 212 if (!forumId) { 211 211 - console.warn( 212 212 - `[UPDATE] Category: Forum not found for DID ${event.did}` 213 213 - ); 213 213 + this.logger.warn("Category: Forum not found for DID", { 214 214 + operation: "Category UPDATE", 215 215 + did: event.did, 216 216 + }); 214 217 return null; 215 218 } 216 219 ··· 238 241 ); 239 242 240 243 if (!categoryId) { 241 241 - console.error("Failed to index board: category not found", { 244 244 + this.logger.error("Failed to index board: category not found", { 242 245 operation: "Board CREATE", 243 246 boardDid: event.did, 244 247 boardRkey: event.commit.rkey, ··· 269 272 ); 270 273 271 274 if (!categoryId) { 272 272 - console.error("Failed to index board: category not found", { 275 275 + this.logger.error("Failed to index board: category not found", { 273 276 operation: "Board UPDATE", 274 277 boardDid: event.did, 275 278 boardRkey: event.commit.rkey, ··· 327 330 const forumId = await this.getForumIdByUri(record.forum.forum.uri, tx); 328 331 329 332 if (!forumId) { 330 330 - console.warn( 331 331 - `[CREATE] Membership: Forum not found for ${record.forum.forum.uri}` 332 332 - ); 333 333 + this.logger.warn("Membership: Forum not found", { 334 334 + operation: "Membership CREATE", 335 335 + forumUri: record.forum.forum.uri, 336 336 + }); 333 337 return null; 334 338 } 335 339 ··· 351 355 const forumId = await this.getForumIdByUri(record.forum.forum.uri, tx); 352 356 353 357 if (!forumId) { 354 354 - console.warn( 355 355 - `[UPDATE] Membership: Forum not found for ${record.forum.forum.uri}` 356 356 - ); 358 358 + this.logger.warn("Membership: Forum not found", { 359 359 + operation: "Membership UPDATE", 360 360 + forumUri: record.forum.forum.uri, 361 361 + }); 357 362 return null; 358 363 } 359 364 ··· 378 383 const forumId = await this.getForumIdByDid(event.did, tx); 379 384 380 385 if (!forumId) { 381 381 - console.warn( 382 382 - `[CREATE] ModAction: Forum not found for DID ${event.did}` 383 383 - ); 386 386 + this.logger.warn("ModAction: Forum not found for DID", { 387 387 + operation: "ModAction CREATE", 388 388 + did: event.did, 389 389 + }); 384 390 return null; 385 391 } 386 392 ··· 418 424 const forumId = await this.getForumIdByDid(event.did, tx); 419 425 420 426 if (!forumId) { 421 421 - console.warn( 422 422 - `[UPDATE] ModAction: Forum not found for DID ${event.did}` 423 423 - ); 427 427 + this.logger.warn("ModAction: Forum not found for DID", { 428 428 + operation: "ModAction UPDATE", 429 429 + did: event.did, 430 430 + }); 424 431 return null; 425 432 } 426 433 ··· 480 487 481 488 // Only log success if insert actually happened 482 489 if (!skipped) { 483 483 - console.log( 484 484 - `[CREATE] ${config.name}: ${event.did}/${event.commit.rkey}` 485 485 - ); 490 490 + this.logger.info(`${config.name} created`, { 491 491 + did: event.did, 492 492 + rkey: event.commit.rkey, 493 493 + }); 486 494 } 487 495 return !skipped; 488 496 } catch (error) { 489 489 - console.error( 490 490 - `Failed to index ${config.name.toLowerCase()} create: ${event.did}/${event.commit.rkey}`, 491 491 - error 492 492 - ); 497 497 + this.logger.error(`Failed to index ${config.name.toLowerCase()} create`, { 498 498 + did: event.did, 499 499 + rkey: event.commit.rkey, 500 500 + error: error instanceof Error ? error.message : String(error), 501 501 + }); 493 502 throw error; 494 503 } 495 504 } ··· 527 536 528 537 // Only log success if update actually happened 529 538 if (!skipped) { 530 530 - console.log( 531 531 - `[UPDATE] ${config.name}: ${event.did}/${event.commit.rkey}` 532 532 - ); 539 539 + this.logger.info(`${config.name} updated`, { 540 540 + did: event.did, 541 541 + rkey: event.commit.rkey, 542 542 + }); 533 543 } 534 544 } catch (error) { 535 535 - console.error( 536 536 - `Failed to update ${config.name.toLowerCase()}: ${event.did}/${event.commit.rkey}`, 537 537 - error 538 538 - ); 545 545 + this.logger.error(`Failed to update ${config.name.toLowerCase()}`, { 546 546 + did: event.did, 547 547 + rkey: event.commit.rkey, 548 548 + error: error instanceof Error ? error.message : String(error), 549 549 + }); 539 550 throw error; 540 551 } 541 552 } ··· 567 578 ); 568 579 } 569 580 570 570 - console.log( 571 571 - `[DELETE] ${config.name}: ${event.did}/${event.commit.rkey}` 572 572 - ); 581 581 + this.logger.info(`${config.name} deleted`, { 582 582 + did: event.did, 583 583 + rkey: event.commit.rkey, 584 584 + }); 573 585 } catch (error) { 574 574 - console.error( 575 575 - `Failed to delete ${config.name.toLowerCase()}: ${event.did}/${event.commit.rkey}`, 576 576 - error 577 577 - ); 586 586 + this.logger.error(`Failed to delete ${config.name.toLowerCase()}`, { 587 587 + did: event.did, 588 588 + rkey: event.commit.rkey, 589 589 + error: error instanceof Error ? error.message : String(error), 590 590 + }); 578 591 throw error; 579 592 } 580 593 } ··· 584 597 async handlePostCreate(event: CommitCreateEvent<"space.atbb.post">) { 585 598 const banned = await this.banEnforcer.isBanned(event.did); 586 599 if (banned) { 587 587 - console.log( 588 588 - `[SKIP] Post from banned user: ${event.did}/${event.commit.rkey}` 589 589 - ); 600 600 + this.logger.info("Skipping post from banned user", { 601 601 + did: event.did, 602 602 + rkey: event.commit.rkey, 603 603 + }); 590 604 return; 591 605 } 592 606 await this.genericCreate(this.postConfig, event); ··· 700 714 await this.db.transaction(async (tx) => { 701 715 const forumId = await this.getForumIdByDid(event.did, tx); 702 716 if (!forumId) { 703 703 - console.warn( 704 704 - `[CREATE] ModAction (ban): Forum not found for DID ${event.did}` 705 705 - ); 717 717 + this.logger.warn("ModAction (ban): Forum not found for DID", { 718 718 + operation: "ModAction CREATE", 719 719 + did: event.did, 720 720 + }); 706 721 skipped = true; 707 722 return; 708 723 } ··· 724 739 await this.banEnforcer.applyBan(record.subject.did!, tx); 725 740 }); 726 741 if (!skipped) { 727 727 - console.log( 728 728 - `[CREATE] ModAction (ban): ${event.did}/${event.commit.rkey}` 729 729 - ); 742 742 + this.logger.info("ModAction (ban) created", { 743 743 + did: event.did, 744 744 + rkey: event.commit.rkey, 745 745 + }); 730 746 } 731 747 } else if (isUnban) { 732 748 // Custom atomic path: insert unban record + liftBan in one transaction ··· 734 750 await this.db.transaction(async (tx) => { 735 751 const forumId = await this.getForumIdByDid(event.did, tx); 736 752 if (!forumId) { 737 737 - console.warn( 738 738 - `[CREATE] ModAction (unban): Forum not found for DID ${event.did}` 739 739 - ); 753 753 + this.logger.warn("ModAction (unban): Forum not found for DID", { 754 754 + operation: "ModAction CREATE", 755 755 + did: event.did, 756 756 + }); 740 757 skipped = true; 741 758 return; 742 759 } ··· 758 775 await this.banEnforcer.liftBan(record.subject.did!, tx); 759 776 }); 760 777 if (!skipped) { 761 761 - console.log( 762 762 - `[CREATE] ModAction (unban): ${event.did}/${event.commit.rkey}` 763 763 - ); 778 778 + this.logger.info("ModAction (unban) created", { 779 779 + did: event.did, 780 780 + rkey: event.commit.rkey, 781 781 + }); 764 782 } 765 783 } else { 766 784 // Generic path for all other mod actions (mute, pin, lock, delete, etc.) ··· 771 789 record.action === "space.atbb.modAction.ban" || 772 790 record.action === "space.atbb.modAction.unban" 773 791 ) { 774 774 - console.warn( 775 775 - "[CREATE] ModAction: ban/unban action missing subject.did, skipping enforcement", 776 776 - { did: event.did, rkey: event.commit.rkey, action: record.action } 777 777 - ); 792 792 + this.logger.warn("ModAction: ban/unban action missing subject.did, skipping enforcement", { 793 793 + did: event.did, 794 794 + rkey: event.commit.rkey, 795 795 + action: record.action, 796 796 + }); 778 797 } 779 798 } 780 799 } catch (error) { 781 781 - console.error( 782 782 - `Failed to index ModAction create: ${event.did}/${event.commit.rkey}`, 783 783 - error 784 784 - ); 800 800 + this.logger.error("Failed to index ModAction create", { 801 801 + did: event.did, 802 802 + rkey: event.commit.rkey, 803 803 + error: error instanceof Error ? error.message : String(error), 804 804 + }); 785 805 throw error; 786 806 } 787 807 } ··· 831 851 } 832 852 }); 833 853 834 834 - console.log( 835 835 - `[DELETE] ModAction: ${event.did}/${event.commit.rkey}` 836 836 - ); 854 854 + this.logger.info("ModAction deleted", { 855 855 + did: event.did, 856 856 + rkey: event.commit.rkey, 857 857 + }); 837 858 } catch (error) { 838 838 - console.error( 839 839 - `Failed to delete modAction: ${event.did}/${event.commit.rkey}`, 840 840 - error 841 841 - ); 859 859 + this.logger.error("Failed to delete modAction", { 860 860 + did: event.did, 861 861 + rkey: event.commit.rkey, 862 862 + error: error instanceof Error ? error.message : String(error), 863 863 + }); 842 864 throw error; 843 865 } 844 866 } ··· 848 870 async handleReactionCreate( 849 871 event: CommitCreateEvent<"space.atbb.reaction"> 850 872 ) { 851 851 - console.log(`[CREATE] Reaction: ${event.did}/${event.commit.rkey} (not implemented)`); 873 873 + this.logger.info("Reaction created (not implemented)", { did: event.did, rkey: event.commit.rkey }); 852 874 // TODO: Add reactions table to schema 853 875 } 854 876 855 877 async handleReactionUpdate( 856 878 event: CommitUpdateEvent<"space.atbb.reaction"> 857 879 ) { 858 858 - console.log(`[UPDATE] Reaction: ${event.did}/${event.commit.rkey} (not implemented)`); 880 880 + this.logger.info("Reaction updated (not implemented)", { did: event.did, rkey: event.commit.rkey }); 859 881 // TODO: Add reactions table to schema 860 882 } 861 883 862 884 async handleReactionDelete( 863 885 event: CommitDeleteEvent<"space.atbb.reaction"> 864 886 ) { 865 865 - console.log(`[DELETE] Reaction: ${event.did}/${event.commit.rkey} (not implemented)`); 887 887 + this.logger.info("Reaction deleted (not implemented)", { did: event.did, rkey: event.commit.rkey }); 866 888 // TODO: Add reactions table to schema 867 889 } 868 890 ··· 882 904 handle: null, // Will be updated by identity events 883 905 indexedAt: new Date(), 884 906 }); 885 885 - console.log(`[USER] Created user: ${did}`); 907 907 + this.logger.info("Created user", { did }); 886 908 } 887 909 } catch (error) { 888 888 - console.error(`Failed to ensure user exists: ${did}`, error); 910 910 + this.logger.error("Failed to ensure user exists", { 911 911 + did, 912 912 + error: error instanceof Error ? error.message : String(error), 913 913 + }); 889 914 throw error; 890 915 } 891 916 } ··· 910 935 911 936 return result.length > 0 ? result[0].id : null; 912 937 } catch (error) { 913 913 - console.error("Database error in getForumIdByUri", { 938 938 + this.logger.error("Database error in getForumIdByUri", { 914 939 operation: "getForumIdByUri", 915 940 forumUri, 916 941 error: error instanceof Error ? error.message : String(error), ··· 937 962 938 963 return result.length > 0 ? result[0].id : null; 939 964 } catch (error) { 940 940 - console.error("Database error in getForumIdByDid", { 965 965 + this.logger.error("Database error in getForumIdByDid", { 941 966 operation: "getForumIdByDid", 942 967 forumDid, 943 968 error: error instanceof Error ? error.message : String(error), ··· 986 1011 .limit(1); 987 1012 return result?.id ?? null; 988 1013 } catch (error) { 989 989 - console.error("Database error in getBoardIdByUri", { 1014 1014 + this.logger.error("Database error in getBoardIdByUri", { 990 1015 operation: "getBoardIdByUri", 991 1016 uri, 992 1017 did: parsed.did, ··· 1017 1042 .limit(1); 1018 1043 return result?.id ?? null; 1019 1044 } catch (error) { 1020 1020 - console.error("Database error in getCategoryIdByUri", { 1045 1045 + this.logger.error("Database error in getCategoryIdByUri", { 1021 1046 operation: "getCategoryIdByUri", 1022 1047 uri, 1023 1048 did: parsed.did,

+12 -7

apps/appview/src/lib/reconnection-manager.ts

··· 1 1 + import type { Logger } from "@atbb/logger"; 2 2 + 1 3 /** 2 4 * Manages reconnection attempts with exponential backoff. 3 5 * ··· 14 16 */ 15 17 constructor( 16 18 private maxAttempts: number, 17 17 - private baseDelayMs: number 19 19 + private baseDelayMs: number, 20 20 + private logger: Logger 18 21 ) {} 19 22 20 23 /** ··· 25 28 */ 26 29 async attemptReconnect(reconnectFn: () => Promise<void>): Promise<void> { 27 30 if (this.attempts >= this.maxAttempts) { 28 28 - console.error( 29 29 - `[FATAL] Max reconnect attempts (${this.maxAttempts}) reached. Manual intervention required.` 30 30 - ); 31 31 + this.logger.fatal("Max reconnect attempts reached - manual intervention required", { 32 32 + maxAttempts: this.maxAttempts, 33 33 + }); 31 34 throw new Error('Max reconnection attempts exceeded'); 32 35 } 33 36 34 37 this.attempts++; 35 38 const delay = this.baseDelayMs * Math.pow(2, this.attempts - 1); 36 39 37 37 - console.log( 38 38 - `Attempting to reconnect (${this.attempts}/${this.maxAttempts}) in ${delay}ms` 39 39 - ); 40 40 + this.logger.info("Attempting to reconnect", { 41 41 + attempt: this.attempts, 42 42 + maxAttempts: this.maxAttempts, 43 43 + delayMs: delay, 44 44 + }); 40 45 41 46 await this.sleep(delay); 42 47 await reconnectFn();

+10 -8

apps/appview/src/lib/route-errors.ts

··· 1 1 import type { Context } from "hono"; 2 2 import type { AtpAgent } from "@atproto/api"; 3 3 import type { AppContext } from "./app-context.js"; 4 4 + import type { Logger } from "@atbb/logger"; 4 5 import { isProgrammingError, isNetworkError, isDatabaseError } from "./errors.js"; 5 6 6 7 /** ··· 8 9 */ 9 10 interface ErrorContext { 10 11 operation: string; 12 12 + logger: Logger; 11 13 [key: string]: unknown; 12 14 } 13 15 ··· 45 47 ): Response { 46 48 if (isProgrammingError(error)) { 47 49 const { message, stack } = formatError(error); 48 48 - console.error(`CRITICAL: Programming error in ${ctx.operation}`, { 50 50 + ctx.logger.error(`CRITICAL: Programming error in ${ctx.operation}`, { 49 51 ...ctx, 50 52 error: message, 51 53 stack, ··· 53 55 throw error; 54 56 } 55 57 56 56 - console.error(userMessage, { 58 58 + ctx.logger.error(userMessage, { 57 59 ...ctx, 58 60 error: formatError(error).message, 59 61 }); ··· 101 103 ): Response { 102 104 if (isProgrammingError(error)) { 103 105 const { message, stack } = formatError(error); 104 104 - console.error(`CRITICAL: Programming error in ${ctx.operation}`, { 106 106 + ctx.logger.error(`CRITICAL: Programming error in ${ctx.operation}`, { 105 107 ...ctx, 106 108 error: message, 107 109 stack, ··· 109 111 throw error; 110 112 } 111 113 112 112 - console.error(userMessage, { 114 114 + ctx.logger.error(userMessage, { 113 115 ...ctx, 114 116 error: formatError(error).message, 115 117 }); ··· 157 159 ): Response { 158 160 if (isProgrammingError(error)) { 159 161 const { message, stack } = formatError(error); 160 160 - console.error(`CRITICAL: Programming error in ${ctx.operation}`, { 162 162 + ctx.logger.error(`CRITICAL: Programming error in ${ctx.operation}`, { 161 163 ...ctx, 162 164 error: message, 163 165 stack, ··· 165 167 throw error; 166 168 } 167 169 168 168 - console.error(userMessage, { 170 170 + ctx.logger.error(userMessage, { 169 171 ...ctx, 170 172 error: formatError(error).message, 171 173 }); ··· 211 213 operation: string 212 214 ): { agent: AtpAgent; error: null } | { agent: null; error: Response } { 213 215 if (!appCtx.forumAgent) { 214 214 - console.error("CRITICAL: ForumAgent not available", { 216 216 + appCtx.logger.error("CRITICAL: ForumAgent not available", { 215 217 operation, 216 218 forumDid: appCtx.config.forumDid, 217 219 }); ··· 225 227 226 228 const agent = appCtx.forumAgent.getAgent(); 227 229 if (!agent) { 228 228 - console.error("ForumAgent not authenticated", { 230 230 + appCtx.logger.error("ForumAgent not authenticated", { 229 231 operation, 230 232 forumDid: appCtx.config.forumDid, 231 233 });

+3 -3

apps/appview/src/lib/seed-roles.ts

··· 88 88 .limit(1); 89 89 90 90 if (existingRole) { 91 91 - console.log(`Role "${defaultRole.name}" already exists, skipping`, { 91 91 + ctx.logger.info(`Role "${defaultRole.name}" already exists, skipping`, { 92 92 operation: "seedDefaultRoles", 93 93 roleName: defaultRole.name, 94 94 }); ··· 110 110 }, 111 111 }); 112 112 113 113 - console.log(`Created default role "${defaultRole.name}"`, { 113 113 + ctx.logger.info(`Created default role "${defaultRole.name}"`, { 114 114 operation: "seedDefaultRoles", 115 115 roleName: defaultRole.name, 116 116 uri: response.data.uri, ··· 119 119 120 120 created++; 121 121 } catch (error) { 122 122 - console.error(`Failed to seed role "${defaultRole.name}"`, { 122 122 + ctx.logger.error(`Failed to seed role "${defaultRole.name}"`, { 123 123 operation: "seedDefaultRoles", 124 124 roleName: defaultRole.name, 125 125 error: error instanceof Error ? error.message : String(error),

+1 -1

apps/appview/src/lib/session.ts

··· 49 49 } 50 50 51 51 // Unexpected error - log and re-throw 52 52 - console.error("Unexpected error restoring OAuth session", { 52 52 + ctx.logger.error("Unexpected error restoring OAuth session", { 53 53 operation: "restoreOAuthSession", 54 54 did: cookieSession.did, 55 55 error: error instanceof Error ? error.message : String(error),

+7 -3

apps/appview/src/lib/ttl-store.ts

··· 1 1 + import type { Logger } from "@atbb/logger"; 2 2 + 1 3 /** 2 4 * Generic in-memory TTL store with periodic cleanup. 3 5 * ··· 23 25 * @param isExpired - Predicate that returns true when an entry should be evicted. 24 26 * @param storeName - Human-readable name used in structured log messages. 25 27 * @param cleanupIntervalMs - How often the background sweep runs (default: 5 minutes). 28 28 + * @param logger - Optional structured logger for cleanup messages. 26 29 */ 27 30 constructor( 28 31 private readonly isExpired: (value: V) => boolean, 29 32 private readonly storeName: string, 30 30 - cleanupIntervalMs = 5 * 60 * 1000 33 33 + cleanupIntervalMs = 5 * 60 * 1000, 34 34 + private readonly logger?: Logger, 31 35 ) { 32 36 this.cleanupInterval = setInterval( 33 37 () => this.cleanup(), ··· 112 116 } 113 117 114 118 if (expired.length > 0) { 115 115 - console.info(`${this.storeName} cleanup completed`, { 119 119 + this.logger?.info(`${this.storeName} cleanup completed`, { 116 120 operation: `${this.storeName}.cleanup`, 117 121 cleanedCount: expired.length, 118 122 remainingCount: this.entries.size, 119 123 }); 120 124 } 121 125 } catch (error) { 122 122 - console.error(`${this.storeName} cleanup failed`, { 126 126 + this.logger?.error(`${this.storeName} cleanup failed`, { 123 127 operation: `${this.storeName}.cleanup`, 124 128 error: error instanceof Error ? error.message : String(error), 125 129 });

+6 -5

apps/appview/src/middleware/__tests__/require-not-banned.test.ts

··· 3 3 import type { Variables } from "../../types.js"; 4 4 import { requireNotBanned } from "../require-not-banned.js"; 5 5 import type { AppContext } from "../../lib/app-context.js"; 6 6 + import { createMockLogger } from "../../lib/__tests__/mock-logger.js"; 6 7 7 8 // Mock getActiveBans so tests don't need a real database 8 9 vi.mock("../../routes/helpers.js", () => ({ ··· 13 14 const { getActiveBans } = await import("../../routes/helpers.js"); 14 15 const mockGetActiveBans = vi.mocked(getActiveBans); 15 16 16 16 - const stubCtx = {} as unknown as AppContext; 17 17 + const mockLogger = createMockLogger(); 18 18 + const stubCtx = { logger: mockLogger } as unknown as AppContext; 17 19 18 20 /** 19 21 * Build a minimal Hono app with requireNotBanned middleware. ··· 83 85 }); 84 86 85 87 it("returns 503 when ban check fails with database error (fail closed)", async () => { 86 86 - const spy = vi.spyOn(console, "error").mockImplementation(() => {}); 88 88 + const spy = vi.spyOn(stubCtx.logger, "error"); 87 89 mockGetActiveBans.mockRejectedValueOnce(new Error("database query failed")); 88 90 89 91 const app = makeApp(mockUser); ··· 105 107 }); 106 108 107 109 it("returns 503 when ban check fails with network error (fail closed)", async () => { 108 108 - vi.spyOn(console, "error").mockImplementation(() => {}); 109 110 mockGetActiveBans.mockRejectedValueOnce(new Error("fetch failed")); 110 111 111 112 const app = makeApp(mockUser); ··· 119 120 }); 120 121 121 122 it("returns 500 when ban check fails with unexpected error (fail closed)", async () => { 122 122 - const spy = vi.spyOn(console, "error").mockImplementation(() => {}); 123 123 + const spy = vi.spyOn(stubCtx.logger, "error"); 123 124 mockGetActiveBans.mockRejectedValueOnce(new Error("Unexpected internal error")); 124 125 125 126 const app = makeApp(mockUser); ··· 141 142 }); 142 143 143 144 it("re-throws TypeError from ban check (programming error)", async () => { 144 144 - const spy = vi.spyOn(console, "error").mockImplementation(() => {}); 145 145 + const spy = vi.spyOn(stubCtx.logger, "error"); 145 146 const programmingError = new TypeError("Cannot read property 'has' of undefined"); 146 147 mockGetActiveBans.mockImplementationOnce(() => { 147 148 throw programmingError;

+2 -2

apps/appview/src/middleware/auth.ts

··· 73 73 74 74 await next(); 75 75 } catch (error) { 76 76 - console.error("Authentication middleware error", { 76 76 + ctx.logger.error("Authentication middleware error", { 77 77 path: c.req.path, 78 78 error: error instanceof Error ? error.message : String(error), 79 79 }); ··· 123 123 } catch (error) { 124 124 // restoreSession now throws on unexpected errors only 125 125 // Log the unexpected error but don't fail the request 126 126 - console.warn("Unexpected error during optional auth", { 126 126 + ctx.logger.warn("Unexpected error during optional auth", { 127 127 path: c.req.path, 128 128 error: error instanceof Error ? error.message : String(error), 129 129 });

+2 -2

apps/appview/src/middleware/permissions.ts

··· 69 69 70 70 // For expected errors (database connection, network, etc.): 71 71 // Log and fail closed (deny access) 72 72 - console.error("Failed to check permissions", { 72 72 + ctx.logger.error("Failed to check permissions", { 73 73 operation: "checkPermission", 74 74 did, 75 75 permission, ··· 124 124 return role || null; 125 125 } catch (error) { 126 126 // Fail closed: return null on any error to deny access 127 127 - console.error("Failed to query user role", { 127 127 + ctx.logger.error("Failed to query user role", { 128 128 did, 129 129 error: error instanceof Error ? error.message : String(error), 130 130 });

+1

apps/appview/src/middleware/require-not-banned.ts

··· 28 28 } catch (error) { 29 29 return handleSecurityCheckError(c, error, "Unable to verify ban status", { 30 30 operation: `${c.req.method} ${c.req.path} - ban check`, 31 31 + logger: ctx.logger, 31 32 userId: user.did, 32 33 }); 33 34 }

+11

apps/appview/src/routes/__tests__/health.test.ts

··· 9 9 10 10 beforeEach(() => { 11 11 // Mock AppContext with healthy defaults 12 12 + const noopLogger = { 13 13 + debug: () => {}, 14 14 + info: () => {}, 15 15 + warn: () => {}, 16 16 + error: () => {}, 17 17 + fatal: () => {}, 18 18 + child: () => noopLogger, 19 19 + shutdown: async () => {}, 20 20 + } as any; 21 21 + 12 22 ctx = { 13 23 config: {} as any, 24 24 + logger: noopLogger, 14 25 db: { 15 26 execute: async () => ({ rows: [] }), 16 27 } as any,

+9 -12

apps/appview/src/routes/__tests__/helpers.test.ts

··· 724 724 }); 725 725 726 726 it("throws when database query fails", async () => { 727 727 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 727 727 + const mockLogger = { error: vi.fn() } as any; 728 728 const dbError = new Error("Database connection lost"); 729 729 const chainMock = { 730 730 from: vi.fn().mockReturnThis(), ··· 734 734 }; 735 735 const mockDb = { select: vi.fn().mockReturnValue(chainMock) } as any; 736 736 737 737 - await expect(getActiveBans(mockDb, ["did:plc:user1"])).rejects.toThrow("Database connection lost"); 737 737 + await expect(getActiveBans(mockDb, ["did:plc:user1"], mockLogger)).rejects.toThrow("Database connection lost"); 738 738 739 739 - expect(consoleErrorSpy).toHaveBeenCalledWith( 739 739 + expect(mockLogger.error).toHaveBeenCalledWith( 740 740 "Failed to query active bans", 741 741 expect.objectContaining({ operation: "getActiveBans" }) 742 742 ); 743 743 - consoleErrorSpy.mockRestore(); 744 743 }); 745 744 }); 746 745 ··· 893 892 }); 894 893 895 894 it("throws when database query fails", async () => { 896 896 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 895 895 + const mockLogger = { error: vi.fn() } as any; 897 896 const dbError = new Error("Database connection lost"); 898 897 const chainMock = { 899 898 from: vi.fn().mockReturnThis(), ··· 903 902 }; 904 903 const mockDb = { select: vi.fn().mockReturnValue(chainMock) } as any; 905 904 906 906 - await expect(getTopicModStatus(mockDb, BigInt(1))).rejects.toThrow("Database connection lost"); 905 905 + await expect(getTopicModStatus(mockDb, BigInt(1), mockLogger)).rejects.toThrow("Database connection lost"); 907 906 908 908 - expect(consoleErrorSpy).toHaveBeenCalledWith( 907 907 + expect(mockLogger.error).toHaveBeenCalledWith( 909 908 "Failed to query topic moderation status", 910 909 expect.objectContaining({ operation: "getTopicModStatus" }) 911 910 ); 912 912 - consoleErrorSpy.mockRestore(); 913 911 }); 914 912 }); 915 913 ··· 1074 1072 }); 1075 1073 1076 1074 it("throws when database query fails", async () => { 1077 1077 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 1075 1075 + const mockLogger = { error: vi.fn() } as any; 1078 1076 const dbError = new Error("Database connection lost"); 1079 1077 const chainMock = { 1080 1078 from: vi.fn().mockReturnThis(), ··· 1084 1082 }; 1085 1083 const mockDb = { select: vi.fn().mockReturnValue(chainMock) } as any; 1086 1084 1087 1087 - await expect(getHiddenPosts(mockDb, [BigInt(1), BigInt(2)])).rejects.toThrow("Database connection lost"); 1085 1085 + await expect(getHiddenPosts(mockDb, [BigInt(1), BigInt(2)], mockLogger)).rejects.toThrow("Database connection lost"); 1088 1086 1089 1089 - expect(consoleErrorSpy).toHaveBeenCalledWith( 1087 1087 + expect(mockLogger.error).toHaveBeenCalledWith( 1090 1088 "Failed to query hidden posts", 1091 1089 expect.objectContaining({ 1092 1090 operation: "getHiddenPosts", 1093 1091 postIdCount: 2, 1094 1092 }) 1095 1093 ); 1096 1096 - consoleErrorSpy.mockRestore(); 1097 1094 }); 1098 1095 });

+6 -9

apps/appview/src/routes/__tests__/mod.test.ts

··· 1900 1900 1901 1901 // Restore spies 1902 1902 consoleErrorSpy.mockRestore(); 1903 1903 - // Restore spy 1904 1903 dbSelectSpy.mockRestore(); 1905 1904 }); 1906 1905 }); ··· 4197 4196 }); 4198 4197 4199 4198 it("returns null when database query fails (fail-safe behavior)", async () => { 4200 4200 - // Mock console.error to verify logging 4201 4201 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 4199 4199 + const loggerErrorSpy = vi.spyOn(ctx.logger, "error"); 4202 4200 4203 4201 // Mock database query to throw error 4204 4202 const dbSelectSpy = vi.spyOn(ctx.db, "select").mockImplementationOnce(() => { ··· 4215 4213 expect(result).toBeNull(); 4216 4214 4217 4215 // Should log the error 4218 4218 - expect(consoleErrorSpy).toHaveBeenCalledWith( 4216 4216 + expect(loggerErrorSpy).toHaveBeenCalledWith( 4219 4217 "Failed to check active moderation action", 4220 4218 expect.objectContaining({ 4221 4219 operation: "checkActiveAction", ··· 4225 4223 4226 4224 // Restore mocks 4227 4225 dbSelectSpy.mockRestore(); 4228 4228 - consoleErrorSpy.mockRestore(); 4226 4226 + loggerErrorSpy.mockRestore(); 4229 4227 }); 4230 4228 4231 4229 it("re-throws programming errors after logging them as CRITICAL", async () => { 4232 4232 - // Mock console.error to verify logging 4233 4233 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 4230 4230 + const loggerErrorSpy = vi.spyOn(ctx.logger, "error"); 4234 4231 4235 4232 // Mock database query to throw TypeError (programming error) 4236 4233 const dbSelectSpy = vi.spyOn(ctx.db, "select").mockImplementationOnce(() => { ··· 4243 4240 ).rejects.toThrow(TypeError); 4244 4241 4245 4242 // Should log the error with CRITICAL prefix before re-throwing 4246 4246 - expect(consoleErrorSpy).toHaveBeenCalledWith( 4243 4243 + expect(loggerErrorSpy).toHaveBeenCalledWith( 4247 4244 "CRITICAL: Programming error in checkActiveAction", 4248 4245 expect.objectContaining({ 4249 4246 operation: "checkActiveAction", ··· 4253 4250 4254 4251 // Restore mocks 4255 4252 dbSelectSpy.mockRestore(); 4256 4256 - consoleErrorSpy.mockRestore(); 4253 4253 + loggerErrorSpy.mockRestore(); 4257 4254 }); 4258 4255 }); 4259 4256 });

+3 -3

apps/appview/src/routes/__tests__/posts.test.ts

··· 496 496 }); 497 497 498 498 it("returns 503 when ban check fails with database error", async () => { 499 499 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 499 499 + const consoleErrorSpy = vi.spyOn(ctx.logger, "error").mockImplementation(() => {}); 500 500 501 501 const helpers = await import("../helpers.js"); 502 502 const getActiveBansSpy = vi.spyOn(helpers, "getActiveBans"); ··· 530 530 }); 531 531 532 532 it("returns 500 when ban check fails with unexpected error (fail closed)", async () => { 533 533 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 533 533 + const consoleErrorSpy = vi.spyOn(ctx.logger, "error").mockImplementation(() => {}); 534 534 535 535 const helpers = await import("../helpers.js"); 536 536 const getActiveBansSpy = vi.spyOn(helpers, "getActiveBans"); ··· 564 564 }); 565 565 566 566 it("re-throws programming errors from ban check", async () => { 567 567 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 567 567 + const consoleErrorSpy = vi.spyOn(ctx.logger, "error").mockImplementation(() => {}); 568 568 569 569 const helpers = await import("../helpers.js"); 570 570 const getActiveBansSpy = vi.spyOn(helpers, "getActiveBans");

+13 -16

apps/appview/src/routes/__tests__/topics.test.ts

··· 931 931 }); 932 932 933 933 it("returns 503 when ban check fails with database error", async () => { 934 934 - // Mock console.error to suppress error output 935 935 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 934 934 + const loggerErrorSpy = vi.spyOn(ctx.logger, "error").mockImplementation(() => {}); 936 935 937 936 // Import helpers module and spy on getActiveBans 938 937 const helpers = await import("../helpers.js"); ··· 955 954 const data = await res.json(); 956 955 expect(data.error).toBe("Database temporarily unavailable. Please try again later."); 957 956 958 958 - expect(consoleErrorSpy).toHaveBeenCalledWith( 957 957 + expect(loggerErrorSpy).toHaveBeenCalledWith( 959 958 "Unable to verify ban status", 960 959 expect.objectContaining({ 961 960 operation: "POST /api/topics - ban check", ··· 964 963 }) 965 964 ); 966 965 967 967 - consoleErrorSpy.mockRestore(); 966 966 + loggerErrorSpy.mockRestore(); 968 967 getActiveBansSpy.mockRestore(); 969 968 }); 970 969 971 970 it("returns 500 when ban check fails with unexpected error (fail closed)", async () => { 972 972 - // Mock console.error to suppress error output 973 973 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 971 971 + const loggerErrorSpy = vi.spyOn(ctx.logger, "error").mockImplementation(() => {}); 974 972 975 973 // Import helpers module and spy on getActiveBans 976 974 const helpers = await import("../helpers.js"); ··· 993 991 const data = await res.json(); 994 992 expect(data.error).toBe("Unable to verify ban status. Please contact support if this persists."); 995 993 996 996 - expect(consoleErrorSpy).toHaveBeenCalledWith( 994 994 + expect(loggerErrorSpy).toHaveBeenCalledWith( 997 995 "Unable to verify ban status", 998 996 expect.objectContaining({ 999 997 operation: "POST /api/topics - ban check", ··· 1002 1000 }) 1003 1001 ); 1004 1002 1005 1005 - consoleErrorSpy.mockRestore(); 1003 1003 + loggerErrorSpy.mockRestore(); 1006 1004 getActiveBansSpy.mockRestore(); 1007 1005 }); 1008 1006 1009 1007 it("re-throws programming errors instead of catching them", async () => { 1010 1010 - // Mock console.error to capture all error output 1011 1011 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 1008 1008 + const loggerErrorSpy = vi.spyOn(ctx.logger, "error").mockImplementation(() => {}); 1012 1009 1013 1010 // Import helpers module and spy on getActiveBans 1014 1011 const helpers = await import("../helpers.js"); ··· 1036 1033 expect(res.status).toBe(500); 1037 1034 1038 1035 // Verify CRITICAL error was logged before re-throw (not "Unable to verify ban status") 1039 1039 - expect(consoleErrorSpy).toHaveBeenCalledWith( 1036 1036 + expect(loggerErrorSpy).toHaveBeenCalledWith( 1040 1037 "CRITICAL: Programming error in POST /api/topics - ban check", 1041 1038 expect.objectContaining({ 1042 1039 operation: "POST /api/topics - ban check", ··· 1047 1044 ); 1048 1045 1049 1046 // Verify the normal error path was NOT taken (programming errors bypass normal logging) 1050 1050 - expect(consoleErrorSpy).not.toHaveBeenCalledWith( 1047 1047 + expect(loggerErrorSpy).not.toHaveBeenCalledWith( 1051 1048 "Unable to verify ban status", 1052 1049 expect.any(Object) 1053 1050 ); 1054 1051 1055 1055 - consoleErrorSpy.mockRestore(); 1052 1052 + loggerErrorSpy.mockRestore(); 1056 1053 getActiveBansSpy.mockRestore(); 1057 1054 }); 1058 1055 }); ··· 1363 1360 }); 1364 1361 1365 1362 it("returns 200 with all replies when ban lookup fails (fail-open)", async () => { 1366 1366 - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 1363 1363 + const loggerErrorSpy = vi.spyOn(ctx.logger, "error"); 1367 1364 1368 1365 const topicRkey = TID.nextStr(); 1369 1366 const replyRkey = TID.nextStr(); ··· 1404 1401 expect(data.replies).toHaveLength(1); 1405 1402 1406 1403 // Verify error was logged 1407 1407 - expect(consoleErrorSpy).toHaveBeenCalledWith( 1404 1404 + expect(loggerErrorSpy).toHaveBeenCalledWith( 1408 1405 expect.stringContaining("Failed to query bans"), 1409 1406 expect.objectContaining({ operation: "GET /api/topics/:id - ban check" }) 1410 1407 ); 1411 1408 1412 1412 - consoleErrorSpy.mockRestore(); 1409 1409 + loggerErrorSpy.mockRestore(); 1413 1410 getActiveBansSpy.mockRestore(); 1414 1411 }); 1415 1412 });

+14 -10

apps/appview/src/routes/admin.ts

··· 130 130 } catch (error) { 131 131 return handleWriteError(c, error, "Failed to assign role", { 132 132 operation: "POST /api/admin/members/:did/role", 133 133 + logger: ctx.logger, 133 134 targetDid, 134 135 roleUri, 135 136 }); ··· 137 138 } catch (error) { 138 139 return handleReadError(c, error, "Failed to process role assignment", { 139 140 operation: "POST /api/admin/members/:did/role", 141 141 + logger: ctx.logger, 140 142 targetDid, 141 143 roleUri, 142 144 }); ··· 179 181 } catch (error) { 180 182 return handleReadError(c, error, "Failed to retrieve roles", { 181 183 operation: "GET /api/admin/roles", 184 184 + logger: ctx.logger, 182 185 }); 183 186 } 184 187 } ··· 226 229 } catch (error) { 227 230 return handleReadError(c, error, "Failed to retrieve members", { 228 231 operation: "GET /api/admin/members", 232 232 + logger: ctx.logger, 229 233 }); 230 234 } 231 235 } ··· 280 284 } catch (error) { 281 285 return handleReadError(c, error, "Failed to retrieve your membership", { 282 286 operation: "GET /api/admin/members/me", 287 287 + logger: ctx.logger, 283 288 did: user.did, 284 289 }); 285 290 } ··· 314 319 type = force === "catch_up" ? BackfillStatus.CatchUp : BackfillStatus.FullSync; 315 320 } else { 316 321 try { 317 317 - const cursor = await new CursorManager(ctx.db).load(); 322 322 + const cursor = await new CursorManager(ctx.db, ctx.logger).load(); 318 323 type = await backfillManager.checkIfNeeded(cursor); 319 324 } catch (error) { 320 325 if (isProgrammingError(error)) throw error; 321 321 - console.error(JSON.stringify({ 326 326 + ctx.logger.error("Failed to check backfill status", { 322 327 event: "backfill.admin_trigger.check_failed", 323 328 error: error instanceof Error ? error.message : String(error), 324 324 - timestamp: new Date().toISOString(), 325 325 - })); 329 329 + }); 326 330 return c.json({ error: "Failed to check backfill status. Please try again later." }, 500); 327 331 } 328 332 ··· 339 343 progressId = await backfillManager.prepareBackfillRow(type); 340 344 } catch (error) { 341 345 if (isProgrammingError(error)) throw error; 342 342 - console.error(JSON.stringify({ 346 346 + ctx.logger.error("Failed to create backfill row", { 343 347 event: "backfill.admin_trigger.create_row_failed", 344 348 error: error instanceof Error ? error.message : String(error), 345 345 - timestamp: new Date().toISOString(), 346 346 - })); 349 349 + }); 347 350 return c.json({ error: "Failed to start backfill. Please try again later." }, 500); 348 351 } 349 352 350 353 // Fire and forget — don't await so response is immediate 351 354 backfillManager.performBackfill(type, progressId).catch((err) => { 352 352 - console.error(JSON.stringify({ 355 355 + ctx.logger.error("Background backfill failed", { 353 356 event: "backfill.admin_trigger_failed", 354 357 backfillId: progressId.toString(), 355 358 error: err instanceof Error ? err.message : String(err), 356 356 - timestamp: new Date().toISOString(), 357 357 - })); 359 359 + }); 358 360 }); 359 361 360 362 return c.json({ ··· 413 415 } catch (error) { 414 416 return handleReadError(c, error, "Failed to fetch backfill progress", { 415 417 operation: "GET /api/admin/backfill/:id", 418 418 + logger: ctx.logger, 416 419 id, 417 420 }); 418 421 } ··· 455 458 } catch (error) { 456 459 return handleReadError(c, error, "Failed to fetch backfill errors", { 457 460 operation: "GET /api/admin/backfill/:id/errors", 461 461 + logger: ctx.logger, 458 462 id, 459 463 }); 460 464 }

+13 -44

apps/appview/src/routes/auth.ts

··· 48 48 state, 49 49 }); 50 50 51 51 - console.log(JSON.stringify({ 52 52 - event: "oauth.login.initiated", 53 53 - handle, 54 54 - timestamp: new Date().toISOString(), 55 55 - })); 51 51 + ctx.logger.info("OAuth login initiated", { handle }); 56 52 57 53 // Redirect to PDS authorization endpoint 58 54 return c.redirect(authUrl.toString()); ··· 65 61 error.message.includes("invalid") 66 62 ); 67 63 68 68 - console.error("Failed to initiate OAuth login", { 64 64 + ctx.logger.error("Failed to initiate OAuth login", { 69 65 operation: "GET /api/auth/login", 70 66 handle, 71 67 isClientError, ··· 109 105 110 106 // Handle user denial 111 107 if (error === "access_denied") { 112 112 - console.log(JSON.stringify({ 113 113 - event: "oauth.callback.denied", 114 114 - timestamp: new Date().toISOString(), 115 115 - })); 108 108 + ctx.logger.info("OAuth callback denied"); 116 109 117 110 return c.redirect( 118 111 `/?error=access_denied&message=${encodeURIComponent("You denied access to the forum.")}` ··· 137 130 handle = profile.data.handle; 138 131 } catch (error) { 139 132 // Handle fetch is critical - fail the login if we can't get it 140 140 - console.error("Failed to fetch user handle during callback - failing login", { 133 133 + ctx.logger.error("Failed to fetch user handle during callback - failing login", { 141 134 operation: "GET /api/auth/callback", 142 135 did: session.did, 143 136 error: error instanceof Error ? error.message : String(error), ··· 153 146 ); 154 147 } 155 148 156 156 - console.log(JSON.stringify({ 157 157 - event: "oauth.callback.success", 158 158 - did: session.did, 159 159 - handle, 160 160 - timestamp: new Date().toISOString(), 161 161 - })); 149 149 + ctx.logger.info("OAuth callback success", { did: session.did, handle }); 162 150 163 151 // Attempt to create membership record 164 152 try { ··· 166 154 const result = await createMembershipForUser(ctx, agent, session.did); 167 155 168 156 if (result.created) { 169 169 - console.log(JSON.stringify({ 170 170 - event: "oauth.callback.membership.created", 171 171 - did: session.did, 172 172 - uri: result.uri, 173 173 - timestamp: new Date().toISOString(), 174 174 - })); 157 157 + ctx.logger.info("OAuth callback membership created", { did: session.did, uri: result.uri }); 175 158 } else { 176 176 - console.log(JSON.stringify({ 177 177 - event: "oauth.callback.membership.exists", 178 178 - did: session.did, 179 179 - timestamp: new Date().toISOString(), 180 180 - })); 159 159 + ctx.logger.info("OAuth callback membership exists", { did: session.did }); 181 160 } 182 161 } catch (error) { 183 162 // CRITICAL: Don't fail login if membership creation fails 184 184 - console.warn(JSON.stringify({ 185 185 - event: "oauth.callback.membership.failed", 186 186 - did: session.did, 187 187 - error: error instanceof Error ? error.message : String(error), 188 188 - timestamp: new Date().toISOString(), 189 189 - })); 163 163 + ctx.logger.warn("OAuth callback membership failed", { did: session.did, error: error instanceof Error ? error.message : String(error) }); 190 164 // Continue with login flow 191 165 } 192 166 ··· 224 198 225 199 if (isSecurityError) { 226 200 // Log security validation failures with higher severity 227 227 - console.error("OAuth callback security validation failed", { 201 201 + ctx.logger.error("OAuth callback security validation failed", { 228 202 operation: "GET /api/auth/callback", 229 203 securityError: true, 230 204 error: error instanceof Error ? error.message : String(error), 231 231 - timestamp: new Date().toISOString(), 232 205 }); 233 206 return c.json( 234 207 { ··· 239 212 } 240 213 241 214 // Server error (token exchange failed, network issues, etc.) 242 242 - console.error("Failed to complete OAuth callback", { 215 215 + ctx.logger.error("Failed to complete OAuth callback", { 243 216 operation: "GET /api/auth/callback", 244 217 error: error instanceof Error ? error.message : String(error), 245 218 }); ··· 291 264 } catch (error) { 292 265 // restoreOAuthSession now throws on unexpected errors only 293 266 // This is a genuine server error (network failure, etc.) 294 294 - console.error("Unexpected error during session check", { 267 267 + ctx.logger.error("Unexpected error during session check", { 295 268 operation: "GET /api/auth/session", 296 269 error: error instanceof Error ? error.message : String(error), 297 270 }); ··· 329 302 // Revoke tokens at the PDS 330 303 await oauthSession.signOut(); 331 304 332 332 - console.log(JSON.stringify({ 333 333 - event: "oauth.logout", 334 334 - did: cookieSession.did, 335 335 - timestamp: new Date().toISOString(), 336 336 - })); 305 305 + ctx.logger.info("OAuth logout", { did: cookieSession.did }); 337 306 } catch (error) { 338 338 - console.error("Failed to revoke tokens during logout", { 307 307 + ctx.logger.error("Failed to revoke tokens during logout", { 339 308 operation: "GET /api/auth/logout", 340 309 did: cookieSession.did, 341 310 error: error instanceof Error ? error.message : String(error),

+3

apps/appview/src/routes/boards.ts

··· 25 25 } catch (error) { 26 26 return handleReadError(c, error, "Failed to retrieve boards", { 27 27 operation: "GET /api/boards", 28 28 + logger: ctx.logger, 28 29 }); 29 30 } 30 31 }) ··· 50 51 } catch (error) { 51 52 return handleReadError(c, error, "Failed to retrieve board", { 52 53 operation: "GET /api/boards/:id", 54 54 + logger: ctx.logger, 53 55 boardId: raw, 54 56 }); 55 57 } ··· 117 119 } catch (error) { 118 120 return handleReadError(c, error, "Failed to retrieve topics", { 119 121 operation: "GET /api/boards/:id/topics", 122 122 + logger: ctx.logger, 120 123 boardId: id, 121 124 }); 122 125 }

+3

apps/appview/src/routes/categories.ts

··· 30 30 } catch (error) { 31 31 return handleReadError(c, error, "Failed to retrieve categories", { 32 32 operation: "GET /api/categories", 33 33 + logger: ctx.logger, 33 34 }); 34 35 } 35 36 }) ··· 55 56 } catch (error) { 56 57 return handleReadError(c, error, "Failed to retrieve category", { 57 58 operation: "GET /api/categories/:id", 59 59 + logger: ctx.logger, 58 60 categoryId: raw, 59 61 }); 60 62 } ··· 92 94 } catch (error) { 93 95 return handleReadError(c, error, "Failed to retrieve boards", { 94 96 operation: "GET /api/categories/:id/boards", 97 97 + logger: ctx.logger, 95 98 categoryId: id, 96 99 }); 97 100 }

+1

apps/appview/src/routes/forum.ts

··· 26 26 } catch (error) { 27 27 return handleReadError(c, error, "Failed to retrieve forum metadata", { 28 28 operation: "GET /api/forum", 29 29 + logger: ctx.logger, 29 30 }); 30 31 } 31 32 });

+4 -7

apps/appview/src/routes/health.ts

··· 58 58 dbLatency = Date.now() - start; 59 59 } catch (error) { 60 60 dbStatus = "down"; 61 61 - console.error( 62 62 - JSON.stringify({ 63 63 - event: "healthCheck.databaseFailed", 64 64 - timestamp, 65 65 - error: error instanceof Error ? error.message : String(error), 66 66 - }) 67 67 - ); 61 61 + ctx.logger.error("Health check database failed", { 62 62 + event: "healthCheck.databaseFailed", 63 63 + error: error instanceof Error ? error.message : String(error), 64 64 + }); 68 65 } 69 66 70 67 // Check firehose status

+10 -6

apps/appview/src/routes/helpers.ts

··· 1 1 import { users, forums, posts, categories, boards, modActions } from "@atbb/db"; 2 2 import type { Database } from "@atbb/db"; 3 3 + import type { Logger } from "@atbb/logger"; 3 4 import { eq, and, inArray, desc } from "drizzle-orm"; 4 5 import { UnicodeString } from "@atproto/api"; 5 6 import { parseAtUri } from "../lib/at-uri.js"; ··· 397 398 */ 398 399 export async function getActiveBans( 399 400 db: Database, 400 400 - dids: string[] 401 401 + dids: string[], 402 402 + logger?: Logger 401 403 ): Promise<Set<string>> { 402 404 if (dids.length === 0) { 403 405 return new Set(); ··· 443 445 444 446 return banned; 445 447 } catch (error) { 446 446 - console.error("Failed to query active bans", { 448 448 + logger?.error("Failed to query active bans", { 447 449 operation: "getActiveBans", 448 450 didCount: dids.length, 449 451 error: error instanceof Error ? error.message : String(error), ··· 461 463 */ 462 464 export async function getTopicModStatus( 463 465 db: Database, 464 464 - topicId: bigint 466 466 + topicId: bigint, 467 467 + logger?: Logger 465 468 ): Promise<{ locked: boolean; pinned: boolean }> { 466 469 try { 467 470 // Look up the topic to get its AT-URI ··· 527 530 mostRecentPinAction?.action === "space.atbb.modAction.pin" || false, 528 531 }; 529 532 } catch (error) { 530 530 - console.error("Failed to query topic moderation status", { 533 533 + logger?.error("Failed to query topic moderation status", { 531 534 operation: "getTopicModStatus", 532 535 topicId: topicId.toString(), 533 536 error: error instanceof Error ? error.message : String(error), ··· 546 549 */ 547 550 export async function getHiddenPosts( 548 551 db: Database, 549 549 - postIds: bigint[] 552 552 + postIds: bigint[], 553 553 + logger?: Logger 550 554 ): Promise<Set<bigint>> { 551 555 if (postIds.length === 0) { 552 556 return new Set(); ··· 618 622 619 623 return hidden; 620 624 } catch (error) { 621 621 - console.error("Failed to query hidden posts", { 625 625 + logger?.error("Failed to query hidden posts", { 622 626 operation: "getHiddenPosts", 623 627 postIdCount: postIds.length, 624 628 error: error instanceof Error ? error.message : String(error),

+14 -2

apps/appview/src/routes/mod.ts

··· 77 77 } catch (error) { 78 78 // Re-throw programming errors (code bugs) - don't hide them 79 79 if (isProgrammingError(error)) { 80 80 - console.error("CRITICAL: Programming error in checkActiveAction", { 80 80 + ctx.logger.error("CRITICAL: Programming error in checkActiveAction", { 81 81 operation: "checkActiveAction", 82 82 subject: JSON.stringify(subject), 83 83 actionType, ··· 88 88 } 89 89 90 90 // Fail safe: return null on runtime errors (don't expose DB errors to callers) 91 91 - console.error("Failed to check active moderation action", { 91 91 + ctx.logger.error("Failed to check active moderation action", { 92 92 operation: "checkActiveAction", 93 93 subject: JSON.stringify(subject), 94 94 actionType, ··· 138 138 } catch (error) { 139 139 return handleReadError(c, error, "Failed to check user membership", { 140 140 operation: "POST /api/mod/ban", 141 141 + logger: ctx.logger, 141 142 targetDid, 142 143 }); 143 144 } ··· 194 195 } catch (error) { 195 196 return handleWriteError(c, error, "Failed to record moderation action", { 196 197 operation: "POST /api/mod/ban", 198 198 + logger: ctx.logger, 197 199 moderatorDid: user.did, 198 200 targetDid, 199 201 forumDid: ctx.config.forumDid, ··· 243 245 } catch (error) { 244 246 return handleReadError(c, error, "Failed to check user membership", { 245 247 operation: "DELETE /api/mod/ban/:did", 248 248 + logger: ctx.logger, 246 249 targetDid, 247 250 }); 248 251 } ··· 300 303 } catch (error) { 301 304 return handleWriteError(c, error, "Failed to record moderation action", { 302 305 operation: "DELETE /api/mod/ban/:did", 306 306 + logger: ctx.logger, 303 307 moderatorDid: user.did, 304 308 targetDid, 305 309 forumDid: ctx.config.forumDid, ··· 354 358 } catch (error) { 355 359 return handleReadError(c, error, "Failed to check topic", { 356 360 operation: "POST /api/mod/lock", 361 361 + logger: ctx.logger, 357 362 topicId, 358 363 }); 359 364 } ··· 423 428 } catch (error) { 424 429 return handleWriteError(c, error, "Failed to record moderation action", { 425 430 operation: "POST /api/mod/lock", 431 431 + logger: ctx.logger, 426 432 moderatorDid: user.did, 427 433 topicId, 428 434 postUri, ··· 477 483 } catch (error) { 478 484 return handleReadError(c, error, "Failed to check topic", { 479 485 operation: "DELETE /api/mod/lock/:topicId", 486 486 + logger: ctx.logger, 480 487 topicId: topicIdParam, 481 488 }); 482 489 } ··· 547 554 } catch (error) { 548 555 return handleWriteError(c, error, "Failed to record moderation action", { 549 556 operation: "DELETE /api/mod/lock/:topicId", 557 557 + logger: ctx.logger, 550 558 moderatorDid: user.did, 551 559 topicId: topicIdParam, 552 560 postUri, ··· 610 618 } catch (error) { 611 619 return handleReadError(c, error, "Failed to retrieve post", { 612 620 operation: "POST /api/mod/hide", 621 621 + logger: ctx.logger, 613 622 postId, 614 623 }); 615 624 } ··· 673 682 } catch (error) { 674 683 return handleWriteError(c, error, "Failed to record moderation action", { 675 684 operation: "POST /api/mod/hide", 685 685 + logger: ctx.logger, 676 686 moderatorDid: user.did, 677 687 postId, 678 688 postUri, ··· 732 742 } catch (error) { 733 743 return handleReadError(c, error, "Failed to retrieve post", { 734 744 operation: "DELETE /api/mod/hide/:postId", 745 745 + logger: ctx.logger, 735 746 postId: postIdParam, 736 747 }); 737 748 } ··· 796 807 } catch (error) { 797 808 return handleWriteError(c, error, "Failed to record moderation action", { 798 809 operation: "DELETE /api/mod/hide/:postId", 810 810 + logger: ctx.logger, 799 811 moderatorDid: user.did, 800 812 postId: postIdParam, 801 813 postUri,

+3 -1

apps/appview/src/routes/posts.ts

··· 47 47 48 48 // Check if topic is locked before processing request 49 49 try { 50 50 - const modStatus = await getTopicModStatus(ctx.db, rootId); 50 50 + const modStatus = await getTopicModStatus(ctx.db, rootId, ctx.logger); 51 51 if (modStatus.locked) { 52 52 return c.json({ error: "This topic is locked and not accepting new replies" }, 403); 53 53 } 54 54 } catch (error) { 55 55 return handleSecurityCheckError(c, error, "Unable to verify topic status", { 56 56 operation: "POST /api/posts - lock check", 57 57 + logger: ctx.logger, 57 58 userId: user.did, 58 59 rootId: rootIdStr, 59 60 }); ··· 122 123 } catch (error) { 123 124 return handleWriteError(c, error, "Failed to create post", { 124 125 operation: "POST /api/posts", 126 126 + logger: ctx.logger, 125 127 userId: user.did, 126 128 rootId: rootIdStr, 127 129 parentId: parentIdStr,

+12 -10

apps/appview/src/routes/topics.ts

··· 71 71 ]; 72 72 let bannedUsers = new Set<string>(); 73 73 try { 74 74 - bannedUsers = await getActiveBans(ctx.db, allUserDids); 74 74 + bannedUsers = await getActiveBans(ctx.db, allUserDids, ctx.logger); 75 75 } catch (error) { 76 76 if (isProgrammingError(error)) throw error; 77 77 - console.error("Failed to query bans for topic view - showing all replies", { 77 77 + ctx.logger.error("Failed to query bans for topic view - showing all replies", { 78 78 operation: "GET /api/topics/:id - ban check", 79 79 topicId: id, 80 80 error: error instanceof Error ? error.message : String(error), ··· 85 85 const allPostIds = replyResults.map((r) => r.post.id); 86 86 let hiddenPosts = new Set<bigint>(); 87 87 try { 88 88 - hiddenPosts = await getHiddenPosts(ctx.db, allPostIds); 88 88 + hiddenPosts = await getHiddenPosts(ctx.db, allPostIds, ctx.logger); 89 89 } catch (error) { 90 90 if (isProgrammingError(error)) throw error; 91 91 - console.error("Failed to query hidden posts for topic view - showing all replies", { 91 91 + ctx.logger.error("Failed to query hidden posts for topic view - showing all replies", { 92 92 operation: "GET /api/topics/:id - hidden posts", 93 93 topicId: id, 94 94 error: error instanceof Error ? error.message : String(error), ··· 103 103 // Get lock/pin status - fail open (default unlocked/unpinned if lookup fails) 104 104 let modStatus = { locked: false, pinned: false }; 105 105 try { 106 106 - modStatus = await getTopicModStatus(ctx.db, topicId); 106 106 + modStatus = await getTopicModStatus(ctx.db, topicId, ctx.logger); 107 107 } catch (error) { 108 108 if (isProgrammingError(error)) throw error; 109 109 - console.error("Failed to query topic mod status - showing as unlocked", { 109 109 + ctx.logger.error("Failed to query topic mod status - showing as unlocked", { 110 110 operation: "GET /api/topics/:id - mod status", 111 111 topicId: id, 112 112 error: error instanceof Error ? error.message : String(error), ··· 127 127 } catch (error) { 128 128 return handleReadError(c, error, "Failed to retrieve topic", { 129 129 operation: "GET /api/topics/:id", 130 130 + logger: ctx.logger, 130 131 topicId: id, 131 132 }); 132 133 } ··· 193 194 } 194 195 } catch (error) { 195 196 if (isProgrammingError(error)) { 196 196 - console.error("CRITICAL: Programming error in POST /api/topics (forum lookup)", { 197 197 + ctx.logger.error("CRITICAL: Programming error in POST /api/topics (forum lookup)", { 197 198 operation: "POST /api/topics", 198 199 userId: user.did, 199 200 error: error instanceof Error ? error.message : String(error), ··· 202 203 throw error; 203 204 } 204 205 205 205 - console.error("Failed to look up forum record before writing topic to PDS", { 206 206 + ctx.logger.error("Failed to look up forum record before writing topic to PDS", { 206 207 operation: "POST /api/topics", 207 208 userId: user.did, 208 209 error: error instanceof Error ? error.message : String(error), ··· 224 225 } 225 226 } catch (error) { 226 227 if (isProgrammingError(error)) { 227 227 - console.error("CRITICAL: Programming error in POST /api/topics (board lookup)", { 228 228 + ctx.logger.error("CRITICAL: Programming error in POST /api/topics (board lookup)", { 228 229 operation: "POST /api/topics", 229 230 userId: user.did, 230 231 error: error instanceof Error ? error.message : String(error), ··· 233 234 throw error; 234 235 } 235 236 236 236 - console.error("Failed to look up board record before writing topic to PDS", { 237 237 + ctx.logger.error("Failed to look up board record before writing topic to PDS", { 237 238 operation: "POST /api/topics", 238 239 userId: user.did, 239 240 error: error instanceof Error ? error.message : String(error), ··· 279 280 } catch (error) { 280 281 return handleWriteError(c, error, "Failed to create topic", { 281 282 operation: "POST /api/topics", 283 283 + logger: ctx.logger, 282 284 userId: user.did, 283 285 }); 284 286 }

+3 -2

apps/web/package.json

··· 13 13 "clean": "rm -rf dist" 14 14 }, 15 15 "dependencies": { 16 16 - "hono": "^4.7.0", 17 17 - "@hono/node-server": "^1.14.0" 16 16 + "@atbb/logger": "workspace:*", 17 17 + "@hono/node-server": "^1.14.0", 18 18 + "hono": "^4.7.0" 18 19 }, 19 20 "devDependencies": { 20 21 "@types/node": "^22.0.0",

+10 -5

apps/web/src/index.ts

··· 1 1 import { Hono } from "hono"; 2 2 import { serve } from "@hono/node-server"; 3 3 import { serveStatic } from "@hono/node-server/serve-static"; 4 4 - import { logger } from "hono/logger"; 4 4 + import { requestLogger } from "@atbb/logger/middleware"; 5 5 import { existsSync } from "node:fs"; 6 6 import { resolve } from "node:path"; 7 7 import { webRoutes } from "./routes/index.js"; 8 8 import { loadConfig } from "./lib/config.js"; 9 9 + import { logger } from "./lib/logger.js"; 9 10 10 11 const config = loadConfig(); 12 12 + 11 13 const app = new Hono(); 12 14 13 13 - app.use("*", logger()); 15 15 + app.use("*", requestLogger(logger)); 14 16 15 17 const staticRoot = "./public"; 16 18 if (!existsSync(resolve(staticRoot))) { 17 17 - console.error("CRITICAL: Static file directory not found", { 19 19 + logger.error("Static file directory not found", { 18 20 resolvedPath: resolve(staticRoot), 19 21 cwd: process.cwd(), 20 22 }); ··· 23 25 app.route("/", webRoutes); 24 26 25 27 app.onError((err, c) => { 26 26 - console.error("Unhandled error in web route", { 28 28 + logger.error("Unhandled error in web route", { 27 29 path: c.req.path, 28 30 method: c.req.method, 29 31 error: err.message, ··· 45 47 port: config.port, 46 48 }, 47 49 (info) => { 48 48 - console.log(`atBB Web UI listening on http://localhost:${info.port}`); 50 50 + logger.info("Server started", { 51 51 + url: `http://localhost:${info.port}`, 52 52 + port: info.port, 53 53 + }); 49 54 } 50 55 );

+20 -26

apps/web/src/lib/__tests__/session.test.ts

··· 1 1 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; 2 2 import { getSession, getSessionWithPermissions, canLockTopics, canModeratePosts, canBanUsers } from "../session.js"; 3 3 + import { logger } from "../logger.js"; 4 4 + 5 5 + vi.mock("../logger.js", () => ({ 6 6 + logger: { 7 7 + debug: vi.fn(), 8 8 + info: vi.fn(), 9 9 + warn: vi.fn(), 10 10 + error: vi.fn(), 11 11 + fatal: vi.fn(), 12 12 + }, 13 13 + })); 3 14 4 15 const mockFetch = vi.fn(); 5 16 6 17 describe("getSession", () => { 7 18 beforeEach(() => { 8 19 vi.stubGlobal("fetch", mockFetch); 20 20 + vi.mocked(logger.error).mockClear(); 9 21 }); 10 22 11 23 afterEach(() => { ··· 89 101 expect(result).toEqual({ authenticated: false }); 90 102 }); 91 103 92 92 - it("logs console.error when AppView returns unexpected non-ok status (not 401)", async () => { 93 93 - const consoleSpy = vi 94 94 - .spyOn(console, "error") 95 95 - .mockImplementation(() => {}); 104 104 + it("logs error when AppView returns unexpected non-ok status (not 401)", async () => { 96 105 mockFetch.mockResolvedValueOnce({ 97 106 ok: false, 98 107 status: 500, ··· 104 113 ); 105 114 106 115 expect(result).toEqual({ authenticated: false }); 107 107 - expect(consoleSpy).toHaveBeenCalledWith( 116 116 + expect(logger.error).toHaveBeenCalledWith( 108 117 expect.stringContaining("unexpected non-ok status"), 109 118 expect.objectContaining({ status: 500 }) 110 119 ); 111 111 - 112 112 - consoleSpy.mockRestore(); 113 120 }); 114 121 115 115 - it("does not log console.error for 401 (normal expired session)", async () => { 116 116 - const consoleSpy = vi 117 117 - .spyOn(console, "error") 118 118 - .mockImplementation(() => {}); 122 122 + it("does not log error for 401 (normal expired session)", async () => { 119 123 mockFetch.mockResolvedValueOnce({ 120 124 ok: false, 121 125 status: 401, ··· 123 127 124 128 await getSession("http://localhost:3000", "atbb_session=expired"); 125 129 126 126 - expect(consoleSpy).not.toHaveBeenCalled(); 127 127 - 128 128 - consoleSpy.mockRestore(); 130 130 + expect(logger.error).not.toHaveBeenCalled(); 129 131 }); 130 132 131 133 it("returns unauthenticated when AppView response is malformed", async () => { ··· 147 149 }); 148 150 149 151 it("returns unauthenticated and logs when AppView is unreachable (network error)", async () => { 150 150 - const consoleSpy = vi 151 151 - .spyOn(console, "error") 152 152 - .mockImplementation(() => {}); 153 152 mockFetch.mockRejectedValueOnce(new Error("fetch failed: ECONNREFUSED")); 154 153 155 154 const result = await getSession( ··· 158 157 ); 159 158 160 159 expect(result).toEqual({ authenticated: false }); 161 161 - expect(consoleSpy).toHaveBeenCalledWith( 160 160 + expect(logger.error).toHaveBeenCalledWith( 162 161 expect.stringContaining("network error"), 163 162 expect.objectContaining({ error: expect.stringContaining("ECONNREFUSED") }) 164 163 ); 165 165 - 166 166 - consoleSpy.mockRestore(); 167 164 }); 168 165 169 166 it("returns unauthenticated when AppView returns authenticated:false", async () => { ··· 185 182 describe("getSessionWithPermissions", () => { 186 183 beforeEach(() => { 187 184 vi.stubGlobal("fetch", mockFetch); 185 185 + vi.mocked(logger.error).mockClear(); 188 186 }); 189 187 190 188 afterEach(() => { ··· 239 237 }); 240 238 241 239 it("returns empty permissions without crashing when members/me call throws", async () => { 242 242 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 243 240 mockFetch.mockResolvedValueOnce({ 244 241 ok: true, 245 242 json: () => Promise.resolve({ authenticated: true, did: "did:plc:abc", handle: "alice.bsky.social" }), ··· 249 246 const result = await getSessionWithPermissions("http://localhost:3000", "atbb_session=token"); 250 247 expect(result.authenticated).toBe(true); 251 248 expect(result.permissions.size).toBe(0); 252 252 - expect(consoleSpy).toHaveBeenCalledWith( 249 249 + expect(logger.error).toHaveBeenCalledWith( 253 250 expect.stringContaining("network error"), 254 251 expect.any(Object) 255 252 ); 256 256 - consoleSpy.mockRestore(); 257 253 }); 258 254 259 255 it("does not log error when members/me returns 404 (expected for guests)", async () => { 260 260 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 261 256 mockFetch.mockResolvedValueOnce({ 262 257 ok: true, 263 258 json: () => Promise.resolve({ authenticated: true, did: "did:plc:abc", handle: "alice.bsky.social" }), ··· 265 260 mockFetch.mockResolvedValueOnce({ ok: false, status: 404 }); 266 261 267 262 await getSessionWithPermissions("http://localhost:3000", "atbb_session=token"); 268 268 - expect(consoleSpy).not.toHaveBeenCalled(); 269 269 - consoleSpy.mockRestore(); 263 263 + expect(logger.error).not.toHaveBeenCalled(); 270 264 }); 271 265 272 266 it("forwards cookie header to members/me call", async () => {

+4

apps/web/src/lib/config.ts

··· 1 1 + import type { LogLevel } from "@atbb/logger"; 2 2 + 1 3 export interface WebConfig { 2 4 port: number; 3 5 appviewUrl: string; 6 6 + logLevel: LogLevel; 4 7 } 5 8 6 9 export function loadConfig(): WebConfig { 7 10 return { 8 11 port: parseInt(process.env.WEB_PORT ?? "3001", 10), 9 12 appviewUrl: process.env.APPVIEW_URL ?? "http://localhost:3000", 13 13 + logLevel: (process.env.LOG_LEVEL as LogLevel) ?? "info", 10 14 }; 11 15 }

+9

apps/web/src/lib/logger.ts

··· 1 1 + import { createLogger } from "@atbb/logger"; 2 2 + import type { LogLevel } from "@atbb/logger"; 3 3 + 4 4 + export const logger = createLogger({ 5 5 + service: "atbb-web", 6 6 + version: "0.1.0", 7 7 + environment: process.env.NODE_ENV ?? "development", 8 8 + level: (process.env.LOG_LEVEL as LogLevel) ?? "info", 9 9 + });

+5 -4

apps/web/src/lib/session.ts

··· 1 1 import { isProgrammingError } from "./errors.js"; 2 2 + import { logger } from "./logger.js"; 2 3 3 4 export type WebSession = 4 5 | { authenticated: false } ··· 26 27 27 28 if (!res.ok) { 28 29 if (res.status !== 401) { 29 29 - console.error("getSession: unexpected non-ok status from AppView", { 30 30 + logger.error("getSession: unexpected non-ok status from AppView", { 30 31 operation: "GET /api/auth/session", 31 32 status: res.status, 32 33 }); ··· 47 48 return { authenticated: false }; 48 49 } catch (error) { 49 50 if (isProgrammingError(error)) throw error; 50 50 - console.error( 51 51 + logger.error( 51 52 "getSession: network error — treating as unauthenticated", 52 53 { 53 54 operation: "GET /api/auth/session", ··· 96 97 } 97 98 } else if (res.status !== 404) { 98 99 // 404 = no membership = expected for guests, no log needed 99 99 - console.error( 100 100 + logger.error( 100 101 "getSessionWithPermissions: unexpected status from members/me", 101 102 { 102 103 operation: "GET /api/admin/members/me", ··· 107 108 } 108 109 } catch (error) { 109 110 if (isProgrammingError(error)) throw error; 110 110 - console.error( 111 111 + logger.error( 111 112 "getSessionWithPermissions: network error — continuing with empty permissions", 112 113 { 113 114 operation: "GET /api/admin/members/me",

+19 -18

apps/web/src/routes/__tests__/auth.test.ts

··· 1 1 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; 2 2 + import { logger } from "../../lib/logger.js"; 3 3 + import { createAuthRoutes } from "../auth.js"; 4 4 + 5 5 + vi.mock("../../lib/logger.js", () => ({ 6 6 + logger: { 7 7 + debug: vi.fn(), 8 8 + info: vi.fn(), 9 9 + warn: vi.fn(), 10 10 + error: vi.fn(), 11 11 + fatal: vi.fn(), 12 12 + }, 13 13 + })); 2 14 3 15 const mockFetch = vi.fn(); 4 16 ··· 6 18 beforeEach(() => { 7 19 vi.stubGlobal("fetch", mockFetch); 8 20 vi.stubEnv("APPVIEW_URL", "http://localhost:3000"); 9 9 - vi.resetModules(); 21 21 + vi.mocked(logger.error).mockClear(); 10 22 }); 11 23 12 24 afterEach(() => { ··· 15 27 mockFetch.mockReset(); 16 28 }); 17 29 18 18 - async function loadAuthRoutes() { 19 19 - const mod = await import("../auth.js"); 20 20 - return mod.createAuthRoutes("http://localhost:3000"); 30 30 + function loadAuthRoutes() { 31 31 + return createAuthRoutes("http://localhost:3000"); 21 32 } 22 33 23 34 describe("POST /logout", () => { ··· 70 81 expect(setCookie).toContain("Max-Age=0"); 71 82 }); 72 83 73 73 - it("logs console.error when AppView logout returns non-ok status", async () => { 84 84 + it("logs error when AppView logout returns non-ok status", async () => { 74 85 mockFetch.mockResolvedValueOnce({ ok: false, status: 500 }); 75 75 - const consoleSpy = vi 76 76 - .spyOn(console, "error") 77 77 - .mockImplementation(() => {}); 78 86 79 87 const authRoutes = await loadAuthRoutes(); 80 88 const res = await authRoutes.request("/logout", { method: "POST" }); 81 89 82 90 // Still redirects home despite non-ok response 83 91 expect(res.status).toBe(303); 84 84 - expect(consoleSpy).toHaveBeenCalledWith( 92 92 + expect(logger.error).toHaveBeenCalledWith( 85 93 expect.stringContaining("non-ok status"), 86 94 expect.objectContaining({ status: 500 }) 87 95 ); 88 88 - 89 89 - consoleSpy.mockRestore(); 90 96 }); 91 97 92 98 it("re-throws programming errors (ReferenceError) without clearing the cookie", async () => { ··· 101 107 expect(res.headers.get("set-cookie")).toBeNull(); 102 108 }); 103 109 104 104 - it("logs console.error when AppView logout throws a network error", async () => { 110 110 + it("logs error when AppView logout throws a network error", async () => { 105 111 mockFetch.mockRejectedValueOnce(new Error("fetch failed: ECONNREFUSED")); 106 106 - const consoleSpy = vi 107 107 - .spyOn(console, "error") 108 108 - .mockImplementation(() => {}); 109 112 110 113 const authRoutes = await loadAuthRoutes(); 111 114 const res = await authRoutes.request("/logout", { method: "POST" }); 112 115 113 116 expect(res.status).toBe(303); 114 114 - expect(consoleSpy).toHaveBeenCalledWith( 117 117 + expect(logger.error).toHaveBeenCalledWith( 115 118 expect.stringContaining("Failed to call AppView logout"), 116 119 expect.objectContaining({ error: expect.stringContaining("ECONNREFUSED") }) 117 120 ); 118 118 - 119 119 - consoleSpy.mockRestore(); 120 121 }); 121 122 }); 122 123 });

+14 -6

apps/web/src/routes/__tests__/new-topic.test.tsx

··· 1 1 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; 2 2 3 3 + vi.mock("../../lib/logger.js", () => ({ 4 4 + logger: { 5 5 + debug: vi.fn(), 6 6 + info: vi.fn(), 7 7 + warn: vi.fn(), 8 8 + error: vi.fn(), 9 9 + fatal: vi.fn(), 10 10 + }, 11 11 + })); 12 12 + 3 13 const mockFetch = vi.fn(); 4 14 5 15 describe("createNewTopicRoutes", () => { ··· 346 356 }); 347 357 348 358 it("returns default error message and logs when AppView 400 body is not JSON", async () => { 349 349 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 359 359 + const { logger } = await import("../../lib/logger.js"); 350 360 mockFetch.mockResolvedValueOnce({ 351 361 ok: false, 352 362 status: 400, ··· 362 372 const html = await res.text(); 363 373 expect(html).toContain("form-error"); 364 374 expect(html).toContain("Something went wrong"); 365 365 - expect(consoleSpy).toHaveBeenCalledWith( 375 375 + expect(logger.error).toHaveBeenCalledWith( 366 376 "Failed to parse AppView 400 response body for new topic", 367 377 expect.any(Object) 368 378 ); 369 369 - consoleSpy.mockRestore(); 370 379 }); 371 380 372 381 it("returns generic error fragment and logs on AppView 5xx", async () => { 373 373 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 382 382 + const { logger } = await import("../../lib/logger.js"); 374 383 mockFetch.mockResolvedValueOnce({ ok: false, status: 502 }); 375 384 const routes = await loadNewTopicRoutes(); 376 385 const res = await routes.request("/new-topic", { ··· 382 391 const html = await res.text(); 383 392 expect(html).toContain("form-error"); 384 393 expect(html).toContain("Something went wrong"); 385 385 - expect(consoleSpy).toHaveBeenCalledWith( 394 394 + expect(logger.error).toHaveBeenCalledWith( 386 395 "AppView returned server error for new topic", 387 396 expect.objectContaining({ status: 502 }) 388 397 ); 389 389 - consoleSpy.mockRestore(); 390 398 }); 391 399 392 400 it("returns unavailable error fragment on AppView network error", async () => {

+12 -3

apps/web/src/routes/__tests__/topics.test.tsx

··· 1 1 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; 2 2 3 3 + vi.mock("../../lib/logger.js", () => ({ 4 4 + logger: { 5 5 + debug: vi.fn(), 6 6 + info: vi.fn(), 7 7 + warn: vi.fn(), 8 8 + error: vi.fn(), 9 9 + fatal: vi.fn(), 10 10 + }, 11 11 + })); 12 12 + 3 13 const mockFetch = vi.fn(); 4 14 5 15 describe("createTopicsRoutes", () => { ··· 767 777 }); 768 778 769 779 it("returns generic error fragment and logs on AppView 5xx", async () => { 770 770 - const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {}); 780 780 + const { logger } = await import("../../lib/logger.js"); 771 781 mockFetch.mockResolvedValueOnce({ ok: false, status: 502 }); 772 782 const routes = await loadTopicsRoutes(); 773 783 const res = await routes.request("/topics/1/reply", { ··· 779 789 const html = await res.text(); 780 790 expect(html).toContain("form-error"); 781 791 expect(html).toContain("Something went wrong"); 782 782 - expect(consoleSpy).toHaveBeenCalledWith( 792 792 + expect(logger.error).toHaveBeenCalledWith( 783 793 "AppView returned server error for reply", 784 794 expect.objectContaining({ status: 502 }) 785 795 ); 786 786 - consoleSpy.mockRestore(); 787 796 }); 788 797 789 798 it("returns error fragment on AppView network error", async () => {

+3 -2

apps/web/src/routes/auth.ts

··· 1 1 import { Hono } from "hono"; 2 2 + import { logger } from "../lib/logger.js"; 2 3 3 4 /** 4 5 * POST /logout → calls AppView logout, clears cookie, redirects to / ··· 21 22 }); 22 23 23 24 if (!logoutRes.ok) { 24 24 - console.error("Auth proxy: AppView logout returned non-ok status", { 25 25 + logger.error("Auth proxy: AppView logout returned non-ok status", { 25 26 operation: "POST /logout", 26 27 status: logoutRes.status, 27 28 }); ··· 34 35 ) { 35 36 throw error; // Re-throw programming errors — don't hide code bugs 36 37 } 37 37 - console.error("Auth proxy: Failed to call AppView logout", { 38 38 + logger.error("Auth proxy: Failed to call AppView logout", { 38 39 operation: "POST /logout", 39 40 error: error instanceof Error ? error.message : String(error), 40 41 });

+4 -3

apps/web/src/routes/boards.tsx

··· 5 5 import { getSession } from "../lib/session.js"; 6 6 import { isProgrammingError, isNetworkError, isNotFoundError } from "../lib/errors.js"; 7 7 import { timeAgo } from "../lib/time.js"; 8 8 + import { logger } from "../lib/logger.js"; 8 9 9 10 // API response type shapes 10 11 ··· 168 169 ); 169 170 } catch (error) { 170 171 if (isProgrammingError(error)) throw error; 171 171 - console.error("Failed to load topics for HTMX partial request", { 172 172 + logger.error("Failed to load topics for HTMX partial request", { 172 173 operation: "GET /boards/:id (HTMX partial)", 173 174 boardId, 174 175 offset, ··· 205 206 ); 206 207 } 207 208 208 208 - console.error("Failed to load board page data (stage 1: board + topics)", { 209 209 + logger.error("Failed to load board page data (stage 1: board + topics)", { 209 210 operation: "GET /boards/:id", 210 211 boardId, 211 212 error: error instanceof Error ? error.message : String(error), ··· 230 231 categoryName = category.name; 231 232 } catch (error) { 232 233 if (isProgrammingError(error)) throw error; 233 233 - console.error("Failed to load board page data (stage 2: category)", { 234 234 + logger.error("Failed to load board page data (stage 2: category)", { 234 235 operation: "GET /boards/:id", 235 236 boardId: board.id, 236 237 categoryId: board.categoryId,

+3 -2

apps/web/src/routes/home.tsx

··· 9 9 import { fetchApi } from "../lib/api.js"; 10 10 import { getSession } from "../lib/session.js"; 11 11 import { isProgrammingError, isNetworkError } from "../lib/errors.js"; 12 12 + import { logger } from "../lib/logger.js"; 12 13 13 14 // API response type shapes 14 15 interface ForumResponse { ··· 62 63 categories = categoriesData.categories; 63 64 } catch (error) { 64 65 if (isProgrammingError(error)) throw error; 65 65 - console.error("Failed to load forum homepage data (stage 1: forum + categories)", { 66 66 + logger.error("Failed to load forum homepage data (stage 1: forum + categories)", { 66 67 operation: "GET /", 67 68 error: error instanceof Error ? error.message : String(error), 68 69 }); ··· 91 92 ); 92 93 } catch (error) { 93 94 if (isProgrammingError(error)) throw error; 94 94 - console.error("Failed to load forum homepage data (stage 2: boards)", { 95 95 + logger.error("Failed to load forum homepage data (stage 2: boards)", { 95 96 operation: "GET /", 96 97 error: error instanceof Error ? error.message : String(error), 97 98 });

+5 -4

apps/web/src/routes/mod.ts

··· 1 1 import { Hono } from "hono"; 2 2 import { isProgrammingError } from "../lib/errors.js"; 3 3 + import { logger } from "../lib/logger.js"; 3 4 4 5 /** 5 6 * Single proxy endpoint for all moderation actions. ··· 102 103 }); 103 104 } catch (error) { 104 105 if (isProgrammingError(error)) throw error; 105 105 - console.error("Failed to proxy mod action to AppView", { 106 106 + logger.error("Failed to proxy mod action to AppView", { 106 107 operation: `${method} ${appviewEndpoint}`, 107 108 action, 108 109 error: error instanceof Error ? error.message : String(error), ··· 123 124 let errorMessage = "Something went wrong. Please try again."; 124 125 125 126 if (appviewRes.status === 401) { 126 126 - console.error("AppView returned 401 for mod action — session may have expired", { 127 127 + logger.error("AppView returned 401 for mod action — session may have expired", { 127 128 operation: `${method} ${appviewEndpoint}`, 128 129 action, 129 130 }); 130 131 errorMessage = "You must be logged in to perform this action."; 131 132 } else if (appviewRes.status === 403) { 132 132 - console.error("AppView returned 403 for mod action — permission mismatch", { 133 133 + logger.error("AppView returned 403 for mod action — permission mismatch", { 133 134 operation: `${method} ${appviewEndpoint}`, 134 135 action, 135 136 }); ··· 140 141 // 409 = already active (e.g. locking an already-locked topic) 141 142 errorMessage = "This action is already active."; 142 143 } else if (appviewRes.status >= 500) { 143 143 - console.error("AppView returned server error for mod action", { 144 144 + logger.error("AppView returned server error for mod action", { 144 145 operation: `${method} ${appviewEndpoint}`, 145 146 action, 146 147 status: appviewRes.status,

+8 -7

apps/web/src/routes/new-topic.tsx

··· 7 7 isProgrammingError, 8 8 isNotFoundError, 9 9 } from "../lib/errors.js"; 10 10 + import { logger } from "../lib/logger.js"; 10 11 11 12 interface BoardResponse { 12 13 id: string; ··· 78 79 ); 79 80 } 80 81 81 81 - console.error("Failed to load board for new topic form", { 82 82 + logger.error("Failed to load board for new topic form", { 82 83 operation: "GET /new-topic", 83 84 boardId: boardIdParam, 84 85 error: error instanceof Error ? error.message : String(error), ··· 158 159 try { 159 160 body = await c.req.parseBody(); 160 161 } catch (error) { 161 161 - console.error("Failed to parse request body for POST /new-topic", { 162 162 + logger.error("Failed to parse request body for POST /new-topic", { 162 163 operation: "POST /new-topic", 163 164 error: error instanceof Error ? error.message : String(error), 164 165 }); ··· 198 199 }); 199 200 } catch (error) { 200 201 if (isProgrammingError(error)) throw error; 201 201 - console.error("Failed to proxy new topic to AppView", { 202 202 + logger.error("Failed to proxy new topic to AppView", { 202 203 operation: "POST /new-topic", 203 204 error: error instanceof Error ? error.message : String(error), 204 205 }); ··· 229 230 errorMessage = msg || "You are not allowed to create topics."; 230 231 } 231 232 } catch { 232 232 - console.error("Failed to parse AppView 403 response body for new topic", { 233 233 + logger.error("Failed to parse AppView 403 response body for new topic", { 233 234 operation: "POST /new-topic", 234 235 }); 235 236 errorMessage = "You are not allowed to create topics."; ··· 239 240 const errBody = (await appviewRes.json()) as { error?: string }; 240 241 errorMessage = errBody.error ?? errorMessage; 241 242 } catch { 242 242 - console.error("Failed to parse AppView 400 response body for new topic", { 243 243 + logger.error("Failed to parse AppView 400 response body for new topic", { 243 244 operation: "POST /new-topic", 244 245 }); 245 246 } 246 247 } else if (appviewRes.status >= 400 && appviewRes.status < 500) { 247 247 - console.error("AppView returned unexpected client error for new topic", { 248 248 + logger.error("AppView returned unexpected client error for new topic", { 248 249 operation: "POST /new-topic", 249 250 status: appviewRes.status, 250 251 }); 251 252 } else if (appviewRes.status >= 500) { 252 252 - console.error("AppView returned server error for new topic", { 253 253 + logger.error("AppView returned server error for new topic", { 253 254 operation: "POST /new-topic", 254 255 status: appviewRes.status, 255 256 });

+11 -10

apps/web/src/routes/topics.tsx

··· 14 14 isNotFoundError, 15 15 } from "../lib/errors.js"; 16 16 import { timeAgo } from "../lib/time.js"; 17 17 + import { logger } from "../lib/logger.js"; 17 18 18 19 // ─── API response types ─────────────────────────────────────────────────────── 19 20 ··· 291 292 ); 292 293 } catch (error) { 293 294 if (isProgrammingError(error)) throw error; 294 294 - console.error("Failed to load replies for HTMX partial request", { 295 295 + logger.error("Failed to load replies for HTMX partial request", { 295 296 operation: "GET /topics/:id (HTMX partial)", 296 297 topicId, 297 298 offset, ··· 326 327 ); 327 328 } 328 329 329 329 - console.error("Failed to load topic page (stage 1: topic)", { 330 330 + logger.error("Failed to load topic page (stage 1: topic)", { 330 331 operation: "GET /topics/:id", 331 332 topicId, 332 333 error: error instanceof Error ? error.message : String(error), ··· 354 355 categoryId = board.categoryId; 355 356 } catch (error) { 356 357 if (isProgrammingError(error)) throw error; 357 357 - console.error("Failed to load topic page (stage 2: board)", { 358 358 + logger.error("Failed to load topic page (stage 2: board)", { 358 359 operation: "GET /topics/:id", 359 360 topicId, 360 361 boardId: topicData.post.boardId, ··· 371 372 categoryName = category.name; 372 373 } catch (error) { 373 374 if (isProgrammingError(error)) throw error; 374 374 - console.error("Failed to load topic page (stage 3: category)", { 375 375 + logger.error("Failed to load topic page (stage 3: category)", { 375 376 operation: "GET /topics/:id", 376 377 topicId, 377 378 categoryId, ··· 508 509 try { 509 510 body = await c.req.parseBody(); 510 511 } catch (error) { 511 511 - console.error("Failed to parse request body for POST /topics/:id/reply", { 512 512 + logger.error("Failed to parse request body for POST /topics/:id/reply", { 512 513 operation: `POST /topics/${topicId}/reply`, 513 514 topicId, 514 515 error: error instanceof Error ? error.message : String(error), ··· 538 539 }); 539 540 } catch (error) { 540 541 if (isProgrammingError(error)) throw error; 541 541 - console.error("Failed to proxy reply to AppView", { 542 542 + logger.error("Failed to proxy reply to AppView", { 542 543 operation: `POST /topics/${topicId}/reply`, 543 544 topicId, 544 545 error: error instanceof Error ? error.message : String(error), ··· 570 571 errorMessage = msg || "You are not allowed to reply."; 571 572 } 572 573 } catch { 573 573 - console.error("Failed to parse AppView 403 response body for reply", { 574 574 + logger.error("Failed to parse AppView 403 response body for reply", { 574 575 operation: `POST /topics/${topicId}/reply`, 575 576 }); 576 577 errorMessage = "You are not allowed to reply."; ··· 580 581 const errBody = (await appviewRes.json()) as { error?: string }; 581 582 errorMessage = errBody.error ?? errorMessage; 582 583 } catch { 583 583 - console.error("Failed to parse AppView 400 response body for reply", { 584 584 + logger.error("Failed to parse AppView 400 response body for reply", { 584 585 operation: `POST /topics/${topicId}/reply`, 585 586 }); 586 587 } 587 588 } else if (appviewRes.status >= 400 && appviewRes.status < 500) { 588 588 - console.error("AppView returned unexpected client error for reply", { 589 589 + logger.error("AppView returned unexpected client error for reply", { 589 590 operation: `POST /topics/${topicId}/reply`, 590 591 status: appviewRes.status, 591 592 }); 592 593 } else if (appviewRes.status >= 500) { 593 593 - console.error("AppView returned server error for reply", { 594 594 + logger.error("AppView returned server error for reply", { 594 595 operation: `POST /topics/${topicId}/reply`, 595 596 status: appviewRes.status, 596 597 });

+1

packages/atproto/package.json

··· 19 19 "test": "vitest run --passWithNoTests" 20 20 }, 21 21 "dependencies": { 22 22 + "@atbb/logger": "workspace:*", 22 23 "@atproto/api": "^0.15.0" 23 24 }, 24 25 "devDependencies": {

+34 -8

packages/atproto/src/__tests__/forum-agent.test.ts

··· 1 1 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; 2 2 import { ForumAgent } from "../forum-agent.js"; 3 3 import { AtpAgent } from "@atproto/api"; 4 4 + import type { Logger } from "@atbb/logger"; 4 5 5 6 // Mock @atproto/api 6 7 vi.mock("@atproto/api", () => ({ 7 8 AtpAgent: vi.fn(), 8 9 })); 9 10 11 11 + /** Create a no-op logger for tests. */ 12 12 + function createMockLogger(): Logger { 13 13 + const noop = vi.fn(); 14 14 + const logger: Logger = { 15 15 + debug: noop, 16 16 + info: noop, 17 17 + warn: noop, 18 18 + error: noop, 19 19 + fatal: noop, 20 20 + child: () => logger, 21 21 + shutdown: () => Promise.resolve(), 22 22 + }; 23 23 + return logger; 24 24 + } 25 25 + 10 26 describe("ForumAgent", () => { 11 27 let mockAgent: any; 12 28 let mockLogin: any; 29 29 + let mockLogger: Logger; 13 30 let agent: ForumAgent | null = null; 14 31 15 32 beforeEach(() => { ··· 18 35 login: mockLogin, 19 36 session: null, 20 37 }; 38 38 + mockLogger = createMockLogger(); 21 39 (AtpAgent as any).mockImplementation(function () { return mockAgent; }); 22 40 }); 23 41 ··· 34 52 agent = new ForumAgent( 35 53 "https://pds.example.com", 36 54 "forum.example.com", 37 37 - "password" 55 55 + "password", 56 56 + mockLogger 38 57 ); 39 58 40 59 const status = agent.getStatus(); ··· 53 72 agent = new ForumAgent( 54 73 "https://pds.example.com", 55 74 "forum.example.com", 56 56 - "password" 75 75 + "password", 76 76 + mockLogger 57 77 ); 58 78 await agent.initialize(); 59 79 ··· 73 93 agent = new ForumAgent( 74 94 "https://pds.example.com", 75 95 "forum.example.com", 76 76 - "password" 96 96 + "password", 97 97 + mockLogger 77 98 ); 78 99 await agent.initialize(); 79 100 ··· 95 116 agent = new ForumAgent( 96 117 "https://pds.example.com", 97 118 "forum.example.com", 98 98 - "wrong-password" 119 119 + "wrong-password", 120 120 + mockLogger 99 121 ); 100 122 await agent.initialize(); 101 123 ··· 116 138 agent = new ForumAgent( 117 139 "https://pds.example.com", 118 140 "forum.example.com", 119 119 - "password" 141 141 + "password", 142 142 + mockLogger 120 143 ); 121 144 await agent.initialize(); 122 145 ··· 151 174 agent = new ForumAgent( 152 175 "https://pds.example.com", 153 176 "forum.example.com", 154 154 - "password" 177 177 + "password", 178 178 + mockLogger 155 179 ); 156 180 await agent.initialize(); 157 181 ··· 181 205 agent = new ForumAgent( 182 206 "https://pds.example.com", 183 207 "forum.example.com", 184 184 - "password" 208 208 + "password", 209 209 + mockLogger 185 210 ); 186 211 await agent.initialize(); 187 212 ··· 208 233 agent = new ForumAgent( 209 234 "https://pds.example.com", 210 235 "forum.example.com", 211 211 - "password" 236 236 + "password", 237 237 + mockLogger 212 238 ); 213 239 await agent.initialize(); 214 240

+33 -61

packages/atproto/src/forum-agent.ts

··· 1 1 import { AtpAgent } from "@atproto/api"; 2 2 + import type { Logger } from "@atbb/logger"; 2 3 import { isAuthError, isNetworkError } from "./errors.js"; 3 4 4 5 export type ForumAgentStatus = ··· 37 38 constructor( 38 39 private readonly pdsUrl: string, 39 40 private readonly handle: string, 40 40 - private readonly password: string 41 41 + private readonly password: string, 42 42 + private readonly logger: Logger 41 43 ) { 42 44 this.agent = new AtpAgent({ service: pdsUrl }); 43 45 } ··· 111 113 this.lastError = null; 112 114 this.nextRetryAt = null; 113 115 114 114 - console.info( 115 115 - JSON.stringify({ 116 116 - event: "forumAgent.auth.success", 117 117 - service: "ForumAgent", 118 118 - handle: this.handle, 119 119 - did: this.agent.session?.did, 120 120 - timestamp: new Date().toISOString(), 121 121 - }) 122 122 - ); 116 116 + this.logger.info("ForumAgent authenticated", { 117 117 + handle: this.handle, 118 118 + did: this.agent.session?.did, 119 119 + }); 123 120 124 121 // Schedule proactive session refresh 125 122 this.scheduleRefresh(); ··· 134 131 this.retryCount = 0; 135 132 this.nextRetryAt = null; 136 133 137 137 - console.error( 138 138 - JSON.stringify({ 139 139 - event: "forumAgent.auth.permanentFailure", 140 140 - service: "ForumAgent", 141 141 - handle: this.handle, 142 142 - error: error instanceof Error ? error.message : String(error), 143 143 - timestamp: new Date().toISOString(), 144 144 - }) 145 145 - ); 134 134 + this.logger.error("ForumAgent auth permanent failure", { 135 135 + handle: this.handle, 136 136 + error: error instanceof Error ? error.message : String(error), 137 137 + }); 146 138 return; 147 139 } 148 140 ··· 156 148 this.nextRetryAt = new Date(Date.now() + delay); 157 149 this.lastError = "Connection to PDS temporarily unavailable"; 158 150 159 159 - console.warn( 160 160 - JSON.stringify({ 161 161 - event: "forumAgent.auth.retrying", 162 162 - service: "ForumAgent", 163 163 - handle: this.handle, 164 164 - attempt: this.retryCount, 165 165 - maxAttempts: this.maxRetries, 166 166 - retryInMs: delay, 167 167 - error: error instanceof Error ? error.message : String(error), 168 168 - timestamp: new Date().toISOString(), 169 169 - }) 170 170 - ); 151 151 + this.logger.warn("ForumAgent auth retrying", { 152 152 + handle: this.handle, 153 153 + attempt: this.retryCount, 154 154 + maxAttempts: this.maxRetries, 155 155 + retryInMs: delay, 156 156 + error: error instanceof Error ? error.message : String(error), 157 157 + }); 171 158 172 159 this.retryTimer = setTimeout(() => { 173 160 this.attemptAuth(); ··· 183 170 : "Authentication failed"; 184 171 this.nextRetryAt = null; 185 172 186 186 - console.error( 187 187 - JSON.stringify({ 188 188 - event: "forumAgent.auth.failed", 189 189 - service: "ForumAgent", 190 190 - handle: this.handle, 191 191 - attempts: this.retryCount + 1, 192 192 - reason: 193 193 - this.retryCount >= this.maxRetries 194 194 - ? "max retries exceeded" 195 195 - : "unknown error", 196 196 - error: error instanceof Error ? error.message : String(error), 197 197 - timestamp: new Date().toISOString(), 198 198 - }) 199 199 - ); 173 173 + this.logger.error("ForumAgent auth failed", { 174 174 + handle: this.handle, 175 175 + attempts: this.retryCount + 1, 176 176 + reason: 177 177 + this.retryCount >= this.maxRetries 178 178 + ? "max retries exceeded" 179 179 + : "unknown error", 180 180 + error: error instanceof Error ? error.message : String(error), 181 181 + }); 200 182 } 201 183 } 202 184 ··· 234 216 try { 235 217 await this.agent.resumeSession(this.agent.session); 236 218 237 237 - console.debug( 238 238 - JSON.stringify({ 239 239 - event: "forumAgent.session.refreshed", 240 240 - service: "ForumAgent", 241 241 - did: this.agent.session?.did, 242 242 - timestamp: new Date().toISOString(), 243 243 - }) 244 244 - ); 219 219 + this.logger.debug("ForumAgent session refreshed", { 220 220 + did: this.agent.session?.did, 221 221 + }); 245 222 246 223 // Schedule next refresh 247 224 this.scheduleRefresh(); 248 225 } catch (error) { 249 249 - console.warn( 250 250 - JSON.stringify({ 251 251 - event: "forumAgent.session.refreshFailed", 252 252 - service: "ForumAgent", 253 253 - error: error instanceof Error ? error.message : String(error), 254 254 - timestamp: new Date().toISOString(), 255 255 - }) 256 256 - ); 226 226 + this.logger.warn("ForumAgent session refresh failed", { 227 227 + error: error instanceof Error ? error.message : String(error), 228 228 + }); 257 229 258 230 // Refresh failed - transition to retrying and attempt full re-auth 259 231 this.authenticated = false;

+1

packages/cli/package.json

··· 17 17 "dependencies": { 18 18 "@atbb/atproto": "workspace:*", 19 19 "@atbb/db": "workspace:*", 20 20 + "@atbb/logger": "workspace:*", 20 21 "@atproto/api": "^0.15.0", 21 22 "citty": "^0.1.6", 22 23 "consola": "^3.4.0",

+3 -1

packages/cli/src/commands/board.ts

··· 11 11 import { checkEnvironment } from "../lib/preflight.js"; 12 12 import { createBoard } from "../lib/steps/create-board.js"; 13 13 import { isProgrammingError } from "../lib/errors.js"; 14 14 + import { logger } from "../lib/logger.js"; 14 15 15 16 const boardAddCommand = defineCommand({ 16 17 meta: { ··· 77 78 const forumAgent = new ForumAgent( 78 79 config.pdsUrl, 79 80 config.forumHandle, 80 80 - config.forumPassword 81 81 + config.forumPassword, 82 82 + logger 81 83 ); 82 84 try { 83 85 await forumAgent.initialize();

+3 -1

packages/cli/src/commands/category.ts

··· 9 9 import { checkEnvironment } from "../lib/preflight.js"; 10 10 import { createCategory } from "../lib/steps/create-category.js"; 11 11 import { isProgrammingError } from "../lib/errors.js"; 12 12 + import { logger } from "../lib/logger.js"; 12 13 13 14 const categoryAddCommand = defineCommand({ 14 15 meta: { ··· 71 72 const forumAgent = new ForumAgent( 72 73 config.pdsUrl, 73 74 config.forumHandle, 74 74 - config.forumPassword 75 75 + config.forumPassword, 76 76 + logger 75 77 ); 76 78 try { 77 79 await forumAgent.initialize();

+2 -1

packages/cli/src/commands/init.ts

··· 15 15 import { createCategory } from "../lib/steps/create-category.js"; 16 16 import { createBoard } from "../lib/steps/create-board.js"; 17 17 import { isProgrammingError } from "../lib/errors.js"; 18 18 + import { logger } from "../lib/logger.js"; 18 19 19 20 export const initCommand = defineCommand({ 20 21 meta: { ··· 79 80 80 81 // Step 2: Authenticate as Forum DID 81 82 consola.start("Authenticating as Forum DID..."); 82 82 - const forumAgent = new ForumAgent(config.pdsUrl, config.forumHandle, config.forumPassword); 83 83 + const forumAgent = new ForumAgent(config.pdsUrl, config.forumHandle, config.forumPassword, logger); 83 84 await forumAgent.initialize(); 84 85 85 86 if (!forumAgent.isAuthenticated()) {

+63

packages/cli/src/lib/logger.ts

··· 1 1 + import consola from "consola"; 2 2 + import type { Logger, LogAttributes } from "@atbb/logger"; 3 3 + 4 4 + /** 5 5 + * CLI logger adapter that wraps consola to satisfy the Logger interface. 6 6 + * 7 7 + * This allows ForumAgent (which requires a structured Logger) to log through 8 8 + * consola for consistent CLI output. The CLI's own user-facing messages 9 9 + * continue to use consola directly. 10 10 + */ 11 11 + class ConsolaLoggerAdapter implements Logger { 12 12 + debug(message: string, attributes?: LogAttributes): void { 13 13 + if (attributes) { 14 14 + consola.debug(message, attributes); 15 15 + } else { 16 16 + consola.debug(message); 17 17 + } 18 18 + } 19 19 + 20 20 + info(message: string, attributes?: LogAttributes): void { 21 21 + if (attributes) { 22 22 + consola.info(message, attributes); 23 23 + } else { 24 24 + consola.info(message); 25 25 + } 26 26 + } 27 27 + 28 28 + warn(message: string, attributes?: LogAttributes): void { 29 29 + if (attributes) { 30 30 + consola.warn(message, attributes); 31 31 + } else { 32 32 + consola.warn(message); 33 33 + } 34 34 + } 35 35 + 36 36 + error(message: string, attributes?: LogAttributes): void { 37 37 + if (attributes) { 38 38 + consola.error(message, attributes); 39 39 + } else { 40 40 + consola.error(message); 41 41 + } 42 42 + } 43 43 + 44 44 + fatal(message: string, attributes?: LogAttributes): void { 45 45 + if (attributes) { 46 46 + consola.fatal(message, attributes); 47 47 + } else { 48 48 + consola.fatal(message); 49 49 + } 50 50 + } 51 51 + 52 52 + child(_attributes: LogAttributes): Logger { 53 53 + // consola doesn't support child loggers with base attributes, 54 54 + // so return this same instance 55 55 + return this; 56 56 + } 57 57 + 58 58 + async shutdown(): Promise<void> { 59 59 + // No-op — consola doesn't need cleanup 60 60 + } 61 61 + } 62 62 + 63 63 + export const logger: Logger = new ConsolaLoggerAdapter();

+39

packages/logger/package.json

··· 1 1 + { 2 2 + "name": "@atbb/logger", 3 3 + "version": "0.1.0", 4 4 + "private": true, 5 5 + "type": "module", 6 6 + "main": "./dist/index.js", 7 7 + "types": "./dist/index.d.ts", 8 8 + "exports": { 9 9 + ".": { 10 10 + "types": "./dist/index.d.ts", 11 11 + "default": "./dist/index.js" 12 12 + }, 13 13 + "./middleware": { 14 14 + "types": "./dist/middleware.d.ts", 15 15 + "default": "./dist/middleware.js" 16 16 + } 17 17 + }, 18 18 + "scripts": { 19 19 + "build": "tsc", 20 20 + "test": "vitest run", 21 21 + "lint": "tsc --noEmit", 22 22 + "lint:fix": "oxlint --fix src/", 23 23 + "clean": "rm -rf dist" 24 24 + }, 25 25 + "dependencies": { 26 26 + "@opentelemetry/api": "^1.9.0", 27 27 + "@opentelemetry/api-logs": "^0.200.0", 28 28 + "@opentelemetry/core": "^2.0.0", 29 29 + "@opentelemetry/resources": "^2.0.0", 30 30 + "@opentelemetry/sdk-logs": "^0.200.0", 31 31 + "@opentelemetry/semantic-conventions": "^1.34.0", 32 32 + "hono": "^4.7.0" 33 33 + }, 34 34 + "devDependencies": { 35 35 + "@types/node": "^22.0.0", 36 36 + "typescript": "^5.7.0", 37 37 + "vitest": "^3.1.0" 38 38 + } 39 39 + }

+432

packages/logger/src/__tests__/logger.test.ts

··· 1 1 + import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; 2 2 + import { createLogger } from "../setup.js"; 3 3 + import { StructuredLogExporter } from "../exporter.js"; 4 4 + import { ExportResultCode } from "@opentelemetry/core"; 5 5 + import { SeverityNumber } from "@opentelemetry/api-logs"; 6 6 + import type { ReadableLogRecord } from "@opentelemetry/sdk-logs"; 7 7 + 8 8 + // ─── Helpers ────────────────────────────────────────────────────────────────── 9 9 + 10 10 + /** 11 11 + * Capture all lines written to process.stdout during the callback. 12 12 + * Returns parsed NDJSON objects. 13 13 + */ 14 14 + async function captureStdout(fn: () => void | Promise<void>): Promise<Record<string, unknown>[]> { 15 15 + const lines: string[] = []; 16 16 + const spy = vi.spyOn(process.stdout, "write").mockImplementation((chunk: unknown) => { 17 17 + if (typeof chunk === "string") { 18 18 + lines.push(...chunk.split("\n").filter(Boolean)); 19 19 + } 20 20 + return true; 21 21 + }); 22 22 + 23 23 + try { 24 24 + await fn(); 25 25 + } finally { 26 26 + spy.mockRestore(); 27 27 + } 28 28 + 29 29 + return lines.map((line) => JSON.parse(line)); 30 30 + } 31 31 + 32 32 + // ─── createLogger / AppLogger ───────────────────────────────────────────────── 33 33 + 34 34 + describe("createLogger", () => { 35 35 + it("emits a valid NDJSON line for info()", async () => { 36 36 + const logger = createLogger({ service: "test-svc" }); 37 37 + 38 38 + const lines = await captureStdout(() => { 39 39 + logger.info("hello world", { requestId: "abc" }); 40 40 + }); 41 41 + 42 42 + expect(lines).toHaveLength(1); 43 43 + const entry = lines[0]; 44 44 + expect(entry.level).toBe("info"); 45 45 + expect(entry.message).toBe("hello world"); 46 46 + expect(entry.service).toBe("test-svc"); 47 47 + expect(entry.requestId).toBe("abc"); 48 48 + expect(typeof entry.timestamp).toBe("string"); 49 49 + // timestamp must be a valid ISO-8601 date 50 50 + expect(new Date(entry.timestamp as string).toISOString()).toBe(entry.timestamp); 51 51 + }); 52 52 + 53 53 + it("emits correct level text for each severity method", async () => { 54 54 + const logger = createLogger({ service: "test-svc", level: "debug" }); 55 55 + 56 56 + for (const [method, expectedLevel] of [ 57 57 + ["debug", "debug"], 58 58 + ["info", "info"], 59 59 + ["warn", "warn"], 60 60 + ["error", "error"], 61 61 + ["fatal", "fatal"], 62 62 + ] as const) { 63 63 + const lines = await captureStdout(() => { 64 64 + logger[method](`${method} message`); 65 65 + }); 66 66 + 67 67 + expect(lines).toHaveLength(1); 68 68 + expect(lines[0].level).toBe(expectedLevel); 69 69 + expect(lines[0].message).toBe(`${method} message`); 70 70 + } 71 71 + }); 72 72 + 73 73 + it("includes version and environment in output when provided", async () => { 74 74 + const logger = createLogger({ 75 75 + service: "test-svc", 76 76 + version: "1.2.3", 77 77 + environment: "staging", 78 78 + }); 79 79 + 80 80 + const lines = await captureStdout(() => { 81 81 + logger.info("tagged message"); 82 82 + }); 83 83 + 84 84 + expect(lines[0].version).toBe("1.2.3"); 85 85 + expect(lines[0].environment).toBe("staging"); 86 86 + }); 87 87 + 88 88 + it("omits version and environment when not provided", async () => { 89 89 + const logger = createLogger({ service: "test-svc" }); 90 90 + 91 91 + const lines = await captureStdout(() => { 92 92 + logger.info("bare message"); 93 93 + }); 94 94 + 95 95 + expect(Object.keys(lines[0])).not.toContain("version"); 96 96 + expect(Object.keys(lines[0])).not.toContain("environment"); 97 97 + }); 98 98 + 99 99 + it("spreads numeric and boolean attributes into top-level fields", async () => { 100 100 + const logger = createLogger({ service: "test-svc" }); 101 101 + 102 102 + const lines = await captureStdout(() => { 103 103 + logger.info("typed attrs", { count: 42, success: true }); 104 104 + }); 105 105 + 106 106 + expect(lines[0].count).toBe(42); 107 107 + expect(lines[0].success).toBe(true); 108 108 + }); 109 109 + }); 110 110 + 111 111 + // ─── Level filtering ────────────────────────────────────────────────────────── 112 112 + 113 113 + describe("AppLogger level filtering", () => { 114 114 + it("suppresses messages below the configured level", async () => { 115 115 + const logger = createLogger({ service: "test-svc", level: "warn" }); 116 116 + 117 117 + const lines = await captureStdout(() => { 118 118 + logger.debug("suppressed debug"); 119 119 + logger.info("suppressed info"); 120 120 + logger.warn("allowed warn"); 121 121 + logger.error("allowed error"); 122 122 + }); 123 123 + 124 124 + expect(lines).toHaveLength(2); 125 125 + expect(lines[0].level).toBe("warn"); 126 126 + expect(lines[1].level).toBe("error"); 127 127 + }); 128 128 + 129 129 + it("emits all levels when level is debug", async () => { 130 130 + const logger = createLogger({ service: "test-svc", level: "debug" }); 131 131 + 132 132 + const lines = await captureStdout(() => { 133 133 + logger.debug("d"); 134 134 + logger.info("i"); 135 135 + logger.warn("w"); 136 136 + logger.error("e"); 137 137 + logger.fatal("f"); 138 138 + }); 139 139 + 140 140 + expect(lines).toHaveLength(5); 141 141 + }); 142 142 + 143 143 + it("only emits fatal when level is fatal", async () => { 144 144 + const logger = createLogger({ service: "test-svc", level: "fatal" }); 145 145 + 146 146 + const lines = await captureStdout(() => { 147 147 + logger.debug("d"); 148 148 + logger.info("i"); 149 149 + logger.warn("w"); 150 150 + logger.error("e"); 151 151 + logger.fatal("f"); 152 152 + }); 153 153 + 154 154 + expect(lines).toHaveLength(1); 155 155 + expect(lines[0].level).toBe("fatal"); 156 156 + }); 157 157 + }); 158 158 + 159 159 + // ─── child() attribute inheritance ─────────────────────────────────────────── 160 160 + 161 161 + describe("AppLogger child()", () => { 162 162 + it("inherits base attributes from parent", async () => { 163 163 + const logger = createLogger({ service: "test-svc" }); 164 164 + const child = logger.child({ requestId: "req-123", component: "auth" }); 165 165 + 166 166 + const lines = await captureStdout(() => { 167 167 + child.info("child message"); 168 168 + }); 169 169 + 170 170 + expect(lines[0].requestId).toBe("req-123"); 171 171 + expect(lines[0].component).toBe("auth"); 172 172 + expect(lines[0].message).toBe("child message"); 173 173 + }); 174 174 + 175 175 + it("call-site attributes override child base attributes", async () => { 176 176 + const logger = createLogger({ service: "test-svc" }); 177 177 + const child = logger.child({ requestId: "base-id" }); 178 178 + 179 179 + const lines = await captureStdout(() => { 180 180 + child.info("override", { requestId: "override-id" }); 181 181 + }); 182 182 + 183 183 + expect(lines[0].requestId).toBe("override-id"); 184 184 + }); 185 185 + 186 186 + it("parent logger is not affected by child attributes", async () => { 187 187 + const logger = createLogger({ service: "test-svc" }); 188 188 + logger.child({ requestId: "req-123" }); // create child to ensure isolation 189 189 + 190 190 + const lines = await captureStdout(() => { 191 191 + logger.info("parent message"); 192 192 + }); 193 193 + 194 194 + expect(Object.keys(lines[0])).not.toContain("requestId"); 195 195 + }); 196 196 + 197 197 + it("child of child accumulates attributes from both ancestors", async () => { 198 198 + const logger = createLogger({ service: "test-svc" }); 199 199 + const child = logger.child({ layer: "A" }); 200 200 + const grandchild = child.child({ layer: "B", extra: "yes" }); 201 201 + 202 202 + const lines = await captureStdout(() => { 203 203 + grandchild.info("deep"); 204 204 + }); 205 205 + 206 206 + // layer from grandchild overrides layer from child 207 207 + expect(lines[0].layer).toBe("B"); 208 208 + expect(lines[0].extra).toBe("yes"); 209 209 + }); 210 210 + }); 211 211 + 212 212 + // ─── StructuredLogExporter ──────────────────────────────────────────────────── 213 213 + 214 214 + describe("StructuredLogExporter", () => { 215 215 + it("calls resultCallback with SUCCESS on normal export", () => { 216 216 + const exporter = new StructuredLogExporter(); 217 217 + const writeSpy = vi.spyOn(process.stdout, "write").mockReturnValue(true); 218 218 + 219 219 + const callback = vi.fn(); 220 220 + exporter.export([], callback); 221 221 + 222 222 + expect(callback).toHaveBeenCalledWith({ code: ExportResultCode.SUCCESS }); 223 223 + writeSpy.mockRestore(); 224 224 + }); 225 225 + 226 226 + it("calls resultCallback with FAILED when stdout.write throws", () => { 227 227 + const exporter = new StructuredLogExporter(); 228 228 + const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => { 229 229 + throw new Error("EPIPE"); 230 230 + }); 231 231 + 232 232 + const record = { 233 233 + hrTime: [1700000000, 0] as [number, number], 234 234 + severityNumber: SeverityNumber.INFO, 235 235 + body: "test", 236 236 + resource: { attributes: {} }, 237 237 + attributes: {}, 238 238 + } as unknown as ReadableLogRecord; 239 239 + 240 240 + const callback = vi.fn(); 241 241 + exporter.export([record], callback); 242 242 + 243 243 + expect(callback).toHaveBeenCalledWith({ code: ExportResultCode.FAILED }); 244 244 + writeSpy.mockRestore(); 245 245 + }); 246 246 + 247 247 + it("calls resultCallback with FAILED when JSON.stringify throws (circular ref)", () => { 248 248 + const exporter = new StructuredLogExporter(); 249 249 + const writeSpy = vi.spyOn(process.stdout, "write").mockReturnValue(true); 250 250 + 251 251 + // Create a log record whose attributes contain a circular reference 252 252 + const circular: Record<string, unknown> = {}; 253 253 + circular.self = circular; 254 254 + 255 255 + const record = { 256 256 + hrTime: [1700000000, 0] as [number, number], 257 257 + severityNumber: SeverityNumber.INFO, 258 258 + body: "circular test", 259 259 + resource: { attributes: {} }, 260 260 + attributes: circular, 261 261 + } as unknown as ReadableLogRecord; 262 262 + 263 263 + const callback = vi.fn(); 264 264 + exporter.export([record], callback); 265 265 + 266 266 + expect(callback).toHaveBeenCalledWith({ code: ExportResultCode.FAILED }); 267 267 + writeSpy.mockRestore(); 268 268 + }); 269 269 + 270 270 + describe("hrTimeToISO arithmetic", () => { 271 271 + it("converts [seconds, nanoseconds] to correct ISO string", () => { 272 272 + const exporter = new StructuredLogExporter(); 273 273 + const writeSpy = vi.spyOn(process.stdout, "write").mockReturnValue(true); 274 274 + const lines: Record<string, unknown>[] = []; 275 275 + 276 276 + writeSpy.mockImplementation((chunk) => { 277 277 + if (typeof chunk === "string") { 278 278 + lines.push(...chunk.split("\n").filter(Boolean).map((l) => JSON.parse(l))); 279 279 + } 280 280 + return true; 281 281 + }); 282 282 + 283 283 + const epochSeconds = 1700000000; 284 284 + const nanoseconds = 500_000_000; // 0.5 seconds 285 285 + 286 286 + const record = { 287 287 + hrTime: [epochSeconds, nanoseconds] as [number, number], 288 288 + severityNumber: SeverityNumber.INFO, 289 289 + body: "time test", 290 290 + resource: { attributes: {} }, 291 291 + attributes: {}, 292 292 + } as unknown as ReadableLogRecord; 293 293 + 294 294 + const callback = vi.fn(); 295 295 + exporter.export([record], callback); 296 296 + 297 297 + const expectedMs = epochSeconds * 1000 + nanoseconds / 1_000_000; 298 298 + expect(lines[0].timestamp).toBe(new Date(expectedMs).toISOString()); 299 299 + 300 300 + writeSpy.mockRestore(); 301 301 + }); 302 302 + }); 303 303 + }); 304 304 + 305 305 + // ─── requestLogger middleware ───────────────────────────────────────────────── 306 306 + 307 307 + describe("requestLogger middleware", () => { 308 308 + // eslint-disable-next-line @typescript-eslint/no-explicit-any 309 309 + let writeSpy: any; 310 310 + 311 311 + beforeEach(() => { 312 312 + writeSpy = vi.spyOn(process.stdout, "write").mockReturnValue(true); 313 313 + }); 314 314 + 315 315 + afterEach(() => { 316 316 + writeSpy.mockRestore(); 317 317 + }); 318 318 + 319 319 + function captureLines(): Record<string, unknown>[] { 320 320 + const lines: Record<string, unknown>[] = []; 321 321 + writeSpy.mockImplementation((chunk: unknown) => { 322 322 + if (typeof chunk === "string") { 323 323 + lines.push(...chunk.split("\n").filter(Boolean).map((l) => JSON.parse(l))); 324 324 + } 325 325 + return true; 326 326 + }); 327 327 + return lines; 328 328 + } 329 329 + 330 330 + it("logs 'Request received' at debug and 'Request completed' at info for 2xx", async () => { 331 331 + const { requestLogger } = await import("../middleware.js"); 332 332 + const { Hono } = await import("hono"); 333 333 + 334 334 + const logger = createLogger({ service: "test-svc", level: "debug" }); 335 335 + const lines = captureLines(); 336 336 + 337 337 + const app = new Hono(); 338 338 + app.use("*", requestLogger(logger)); 339 339 + app.get("/ok", (c) => c.json({ ok: true })); 340 340 + 341 341 + await app.request("/ok"); 342 342 + 343 343 + const received = lines.find((l) => l.message === "Request received"); 344 344 + const completed = lines.find((l) => l.message === "Request completed"); 345 345 + 346 346 + expect(received).toBeDefined(); 347 347 + expect(received?.level).toBe("debug"); 348 348 + expect(completed).toBeDefined(); 349 349 + expect(completed?.level).toBe("info"); 350 350 + expect(completed?.status).toBe(200); 351 351 + expect(typeof completed?.duration_ms).toBe("number"); 352 352 + }); 353 353 + 354 354 + it("logs 'Request completed' at warn for 4xx responses", async () => { 355 355 + const { requestLogger } = await import("../middleware.js"); 356 356 + const { Hono } = await import("hono"); 357 357 + 358 358 + const logger = createLogger({ service: "test-svc", level: "debug" }); 359 359 + const lines = captureLines(); 360 360 + 361 361 + const app = new Hono(); 362 362 + app.use("*", requestLogger(logger)); 363 363 + app.get("/bad", (c) => c.json({ error: "bad request" }, 400)); 364 364 + 365 365 + await app.request("/bad"); 366 366 + 367 367 + const completed = lines.find((l) => l.message === "Request completed"); 368 368 + expect(completed?.level).toBe("warn"); 369 369 + expect(completed?.status).toBe(400); 370 370 + }); 371 371 + 372 372 + it("logs 'Request completed' at error for 5xx responses", async () => { 373 373 + const { requestLogger } = await import("../middleware.js"); 374 374 + const { Hono } = await import("hono"); 375 375 + 376 376 + const logger = createLogger({ service: "test-svc", level: "debug" }); 377 377 + const lines = captureLines(); 378 378 + 379 379 + const app = new Hono(); 380 380 + app.use("*", requestLogger(logger)); 381 381 + app.get("/err", (c) => c.json({ error: "server error" }, 500)); 382 382 + 383 383 + await app.request("/err"); 384 384 + 385 385 + const completed = lines.find((l) => l.message === "Request completed"); 386 386 + expect(completed?.level).toBe("error"); 387 387 + expect(completed?.status).toBe(500); 388 388 + }); 389 389 + 390 390 + it("logs 'Request completed' at error level when handler throws (Hono catches internally)", async () => { 391 391 + const { requestLogger } = await import("../middleware.js"); 392 392 + const { Hono } = await import("hono"); 393 393 + 394 394 + const logger = createLogger({ service: "test-svc", level: "debug" }); 395 395 + const lines = captureLines(); 396 396 + 397 397 + const app = new Hono(); 398 398 + app.use("*", requestLogger(logger)); 399 399 + app.get("/throw", () => { 400 400 + throw new Error("handler crashed"); 401 401 + }); 402 402 + 403 403 + // Hono's internal onError catches the throw and returns 500. 404 404 + // The middleware sees next() return normally with c.res.status = 500. 405 405 + const res = await app.request("/throw"); 406 406 + expect(res.status).toBe(500); 407 407 + 408 408 + // Middleware logs "Request completed" at error (status >= 500), not "Request failed" 409 409 + const completed = lines.find((l) => l.message === "Request completed"); 410 410 + expect(completed).toBeDefined(); 411 411 + expect(completed?.level).toBe("error"); 412 412 + expect(completed?.status).toBe(500); 413 413 + }); 414 414 + 415 415 + it("includes method and path in child logger context", async () => { 416 416 + const { requestLogger } = await import("../middleware.js"); 417 417 + const { Hono } = await import("hono"); 418 418 + 419 419 + const logger = createLogger({ service: "test-svc", level: "debug" }); 420 420 + const lines = captureLines(); 421 421 + 422 422 + const app = new Hono(); 423 423 + app.use("*", requestLogger(logger)); 424 424 + app.get("/api/forum", (c) => c.json({ ok: true })); 425 425 + 426 426 + await app.request("/api/forum"); 427 427 + 428 428 + const completed = lines.find((l) => l.message === "Request completed"); 429 429 + expect(completed?.method).toBe("GET"); 430 430 + expect(completed?.path).toBe("/api/forum"); 431 431 + }); 432 432 + });

+100

packages/logger/src/exporter.ts

··· 1 1 + import type { ExportResult } from "@opentelemetry/core"; 2 2 + import { ExportResultCode } from "@opentelemetry/core"; 3 3 + import type { LogRecordExporter, ReadableLogRecord } from "@opentelemetry/sdk-logs"; 4 4 + import { SeverityNumber } from "@opentelemetry/api-logs"; 5 5 + import { 6 6 + ATTR_SERVICE_NAME, 7 7 + ATTR_SERVICE_VERSION, 8 8 + } from "@opentelemetry/semantic-conventions"; 9 9 + 10 10 + const SEVERITY_TEXT: Record<number, string> = { 11 11 + [SeverityNumber.DEBUG]: "debug", 12 12 + [SeverityNumber.DEBUG2]: "debug", 13 13 + [SeverityNumber.DEBUG3]: "debug", 14 14 + [SeverityNumber.DEBUG4]: "debug", 15 15 + [SeverityNumber.INFO]: "info", 16 16 + [SeverityNumber.INFO2]: "info", 17 17 + [SeverityNumber.INFO3]: "info", 18 18 + [SeverityNumber.INFO4]: "info", 19 19 + [SeverityNumber.WARN]: "warn", 20 20 + [SeverityNumber.WARN2]: "warn", 21 21 + [SeverityNumber.WARN3]: "warn", 22 22 + [SeverityNumber.WARN4]: "warn", 23 23 + [SeverityNumber.ERROR]: "error", 24 24 + [SeverityNumber.ERROR2]: "error", 25 25 + [SeverityNumber.ERROR3]: "error", 26 26 + [SeverityNumber.ERROR4]: "error", 27 27 + [SeverityNumber.FATAL]: "fatal", 28 28 + [SeverityNumber.FATAL2]: "fatal", 29 29 + [SeverityNumber.FATAL3]: "fatal", 30 30 + [SeverityNumber.FATAL4]: "fatal", 31 31 + }; 32 32 + 33 33 + /** 34 34 + * Exports OTel log records as newline-delimited JSON to stdout. 35 35 + * 36 36 + * Output format: 37 37 + * {"timestamp":"2026-02-23T12:00:00.000Z","level":"info","message":"Server started","service":"atbb-appview","port":3000} 38 38 + * 39 39 + * Compatible with standard log aggregation tools (ELK, Grafana Loki, Datadog, etc.). 40 40 + */ 41 41 + export class StructuredLogExporter implements LogRecordExporter { 42 42 + export( 43 43 + records: ReadableLogRecord[], 44 44 + resultCallback: (result: ExportResult) => void 45 45 + ): void { 46 46 + try { 47 47 + for (const record of records) { 48 48 + const entry = this.formatRecord(record); 49 49 + process.stdout.write(JSON.stringify(entry) + "\n"); 50 50 + } 51 51 + resultCallback({ code: ExportResultCode.SUCCESS }); 52 52 + } catch { 53 53 + resultCallback({ code: ExportResultCode.FAILED }); 54 54 + } 55 55 + } 56 56 + 57 57 + shutdown(): Promise<void> { 58 58 + return Promise.resolve(); 59 59 + } 60 60 + 61 61 + private formatRecord(record: ReadableLogRecord): Record<string, unknown> { 62 62 + const resourceAttrs = record.resource?.attributes ?? {}; 63 63 + const logAttrs = record.attributes ?? {}; 64 64 + 65 65 + // Build the base log entry 66 66 + const entry: Record<string, unknown> = { 67 67 + timestamp: this.hrTimeToISO(record.hrTime), 68 68 + level: SEVERITY_TEXT[record.severityNumber ?? SeverityNumber.INFO] ?? "info", 69 69 + message: record.body ?? "", 70 70 + }; 71 71 + 72 72 + // Add service metadata from resource 73 73 + const service = resourceAttrs[ATTR_SERVICE_NAME]; 74 74 + if (service) { 75 75 + entry.service = service; 76 76 + } 77 77 + const version = resourceAttrs[ATTR_SERVICE_VERSION]; 78 78 + if (version) { 79 79 + entry.version = version; 80 80 + } 81 81 + const environment = resourceAttrs["deployment.environment.name"]; 82 82 + if (environment) { 83 83 + entry.environment = environment; 84 84 + } 85 85 + 86 86 + // Spread user-provided attributes into the top level 87 87 + for (const [key, value] of Object.entries(logAttrs)) { 88 88 + if (value !== undefined && value !== null) { 89 89 + entry[key] = value; 90 90 + } 91 91 + } 92 92 + 93 93 + return entry; 94 94 + } 95 95 + 96 96 + private hrTimeToISO(hrTime: [number, number]): string { 97 97 + const ms = hrTime[0] * 1000 + hrTime[1] / 1_000_000; 98 98 + return new Date(ms).toISOString(); 99 99 + } 100 100 + }

+7

packages/logger/src/index.ts

··· 1 1 + export { createLogger } from "./setup.js"; 2 2 + export type { 3 3 + Logger, 4 4 + LogLevel, 5 5 + LogAttributes, 6 6 + CreateLoggerOptions, 7 7 + } from "./types.js";

+91

packages/logger/src/logger.ts

··· 1 1 + import type { Logger as IOTelLogger } from "@opentelemetry/api-logs"; 2 2 + import { SeverityNumber } from "@opentelemetry/api-logs"; 3 3 + import type { LoggerProvider } from "@opentelemetry/sdk-logs"; 4 4 + import type { Attributes } from "@opentelemetry/api"; 5 5 + import type { Logger, LogAttributes, LogLevel } from "./types.js"; 6 6 + import { SEVERITY_MAP } from "./types.js"; 7 7 + 8 8 + /** 9 9 + * Structured logger wrapping the OpenTelemetry Logs API. 10 10 + * 11 11 + * Provides an ergonomic interface (info/warn/error/etc.) over the 12 12 + * lower-level OTel LogRecord emit API, with child logger support 13 13 + * for adding persistent context (request ID, component name, etc.). 14 14 + */ 15 15 + export class AppLogger implements Logger { 16 16 + private otelLogger: IOTelLogger; 17 17 + private provider: LoggerProvider; 18 18 + private baseAttributes: LogAttributes; 19 19 + private minSeverity: SeverityNumber; 20 20 + 21 21 + constructor( 22 22 + otelLogger: IOTelLogger, 23 23 + provider: LoggerProvider, 24 24 + baseAttributes: LogAttributes = {}, 25 25 + minSeverity: SeverityNumber = SeverityNumber.INFO 26 26 + ) { 27 27 + this.otelLogger = otelLogger; 28 28 + this.provider = provider; 29 29 + this.baseAttributes = baseAttributes; 30 30 + this.minSeverity = minSeverity; 31 31 + } 32 32 + 33 33 + debug(message: string, attributes?: LogAttributes): void { 34 34 + this.emit(SeverityNumber.DEBUG, "debug", message, attributes); 35 35 + } 36 36 + 37 37 + info(message: string, attributes?: LogAttributes): void { 38 38 + this.emit(SeverityNumber.INFO, "info", message, attributes); 39 39 + } 40 40 + 41 41 + warn(message: string, attributes?: LogAttributes): void { 42 42 + this.emit(SeverityNumber.WARN, "warn", message, attributes); 43 43 + } 44 44 + 45 45 + error(message: string, attributes?: LogAttributes): void { 46 46 + this.emit(SeverityNumber.ERROR, "error", message, attributes); 47 47 + } 48 48 + 49 49 + fatal(message: string, attributes?: LogAttributes): void { 50 50 + this.emit(SeverityNumber.FATAL, "fatal", message, attributes); 51 51 + } 52 52 + 53 53 + child(attributes: LogAttributes): Logger { 54 54 + return new AppLogger( 55 55 + this.otelLogger, 56 56 + this.provider, 57 57 + { ...this.baseAttributes, ...attributes }, 58 58 + this.minSeverity 59 59 + ); 60 60 + } 61 61 + 62 62 + async shutdown(): Promise<void> { 63 63 + await this.provider.shutdown(); 64 64 + } 65 65 + 66 66 + private emit( 67 67 + severityNumber: SeverityNumber, 68 68 + severityText: string, 69 69 + message: string, 70 70 + attributes?: LogAttributes 71 71 + ): void { 72 72 + if (severityNumber < this.minSeverity) { 73 73 + return; 74 74 + } 75 75 + 76 76 + this.otelLogger.emit({ 77 77 + severityNumber, 78 78 + severityText, 79 79 + body: message, 80 80 + attributes: { 81 81 + ...this.baseAttributes, 82 82 + ...attributes, 83 83 + } as Attributes, 84 84 + }); 85 85 + } 86 86 + } 87 87 + 88 88 + /** Resolve a LogLevel string to its OTel SeverityNumber. */ 89 89 + export function resolveLogLevel(level: LogLevel): SeverityNumber { 90 90 + return SEVERITY_MAP[level]; 91 91 + }

+61

packages/logger/src/middleware.ts

··· 1 1 + import type { MiddlewareHandler } from "hono"; 2 2 + import { createMiddleware } from "hono/factory"; 3 3 + import type { Logger } from "./types.js"; 4 4 + 5 5 + /** 6 6 + * Hono middleware that logs structured HTTP request/response data. 7 7 + * 8 8 + * Replaces Hono's built-in `logger()` middleware with OpenTelemetry-backed 9 9 + * structured logging. Each request gets a child logger with request context 10 10 + * that is available to downstream handlers via `c.get("logger")`. 11 11 + * 12 12 + * Log output: 13 13 + * - Incoming request: method, path (at debug level) 14 14 + * - Completed response: method, path, status, duration_ms 15 15 + * (info for 2xx, warn for 4xx, error for 5xx — including errors handled by onError) 16 16 + * 17 17 + * @example 18 18 + * ```ts 19 19 + * import { createLogger } from "@atbb/logger"; 20 20 + * import { requestLogger } from "@atbb/logger/middleware"; 21 21 + * 22 22 + * const logger = createLogger({ service: "atbb-appview" }); 23 23 + * app.use("*", requestLogger(logger)); 24 24 + * 25 25 + * // In route handlers: 26 26 + * app.get("/api/forum", (c) => { 27 27 + * const log = c.get("logger"); 28 28 + * log.info("Fetching forum metadata"); 29 29 + * // ... 30 30 + * }); 31 31 + * ``` 32 32 + */ 33 33 + export function requestLogger(logger: Logger): MiddlewareHandler { 34 34 + return createMiddleware(async (c, next) => { 35 35 + const start = performance.now(); 36 36 + const method = c.req.method; 37 37 + const path = c.req.path; 38 38 + 39 39 + // Create a child logger scoped to this request 40 40 + const reqLogger = logger.child({ 41 41 + method, 42 42 + path, 43 43 + }); 44 44 + 45 45 + // Make the logger available to downstream handlers 46 46 + c.set("logger", reqLogger); 47 47 + 48 48 + reqLogger.debug("Request received"); 49 49 + 50 50 + await next(); 51 51 + 52 52 + const duration = Math.round(performance.now() - start); 53 53 + const status = c.res.status; 54 54 + const level = status >= 500 ? "error" : status >= 400 ? "warn" : "info"; 55 55 + 56 56 + reqLogger[level]("Request completed", { 57 57 + status, 58 58 + duration_ms: duration, 59 59 + }); 60 60 + }); 61 61 + }

+61

packages/logger/src/setup.ts

··· 1 1 + import { 2 2 + LoggerProvider, 3 3 + SimpleLogRecordProcessor, 4 4 + } from "@opentelemetry/sdk-logs"; 5 5 + import { resourceFromAttributes } from "@opentelemetry/resources"; 6 6 + import { 7 7 + ATTR_SERVICE_NAME, 8 8 + ATTR_SERVICE_VERSION, 9 9 + } from "@opentelemetry/semantic-conventions"; 10 10 + import { StructuredLogExporter } from "./exporter.js"; 11 11 + import { AppLogger, resolveLogLevel } from "./logger.js"; 12 12 + import type { CreateLoggerOptions, Logger } from "./types.js"; 13 13 + 14 14 + /** 15 15 + * Create a structured logger backed by the OpenTelemetry Logs SDK. 16 16 + * 17 17 + * Sets up a LoggerProvider with a Resource describing the service, 18 18 + * and a StructuredLogExporter that writes NDJSON to stdout. 19 19 + * 20 20 + * When traces and metrics are added later, the same Resource 21 21 + * can be shared across all signal providers. 22 22 + * 23 23 + * @example 24 24 + * ```ts 25 25 + * const logger = createLogger({ 26 26 + * service: "atbb-appview", 27 27 + * version: "0.1.0", 28 28 + * environment: "development", 29 29 + * level: "debug", 30 30 + * }); 31 31 + * 32 32 + * logger.info("Server started", { port: 3000 }); 33 33 + * logger.error("Query failed", { error: err.message, table: "posts" }); 34 34 + * 35 35 + * const reqLog = logger.child({ requestId: "abc-123" }); 36 36 + * reqLog.info("Handling request"); 37 37 + * ``` 38 38 + */ 39 39 + export function createLogger(options: CreateLoggerOptions): Logger { 40 40 + const resourceAttrs: Record<string, string> = { 41 41 + [ATTR_SERVICE_NAME]: options.service, 42 42 + }; 43 43 + if (options.version) { 44 44 + resourceAttrs[ATTR_SERVICE_VERSION] = options.version; 45 45 + } 46 46 + if (options.environment) { 47 47 + resourceAttrs["deployment.environment.name"] = options.environment; 48 48 + } 49 49 + 50 50 + const resource = resourceFromAttributes(resourceAttrs); 51 51 + const exporter = new StructuredLogExporter(); 52 52 + const processor = new SimpleLogRecordProcessor(exporter); 53 53 + 54 54 + const provider = new LoggerProvider({ resource }); 55 55 + provider.addLogRecordProcessor(processor); 56 56 + 57 57 + const otelLogger = provider.getLogger(options.service); 58 58 + const minSeverity = resolveLogLevel(options.level ?? "info"); 59 59 + 60 60 + return new AppLogger(otelLogger, provider, {}, minSeverity); 61 61 + }

+41

packages/logger/src/types.ts

··· 1 1 + import { SeverityNumber } from "@opentelemetry/api-logs"; 2 2 + 3 3 + /** Log severity levels in ascending order. */ 4 4 + export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal"; 5 5 + 6 6 + /** Map from LogLevel to OTel SeverityNumber. */ 7 7 + export const SEVERITY_MAP: Record<LogLevel, SeverityNumber> = { 8 8 + debug: SeverityNumber.DEBUG, 9 9 + info: SeverityNumber.INFO, 10 10 + warn: SeverityNumber.WARN, 11 11 + error: SeverityNumber.ERROR, 12 12 + fatal: SeverityNumber.FATAL, 13 13 + }; 14 14 + 15 15 + /** Attributes that can be attached to log records. */ 16 16 + export type LogAttributes = Record<string, unknown>; 17 17 + 18 18 + /** Options for creating a logger. */ 19 19 + export interface CreateLoggerOptions { 20 20 + /** Service name (e.g., "atbb-appview"). */ 21 21 + service: string; 22 22 + /** Service version (e.g., "0.1.0"). */ 23 23 + version?: string; 24 24 + /** Deployment environment (e.g., "production", "development"). */ 25 25 + environment?: string; 26 26 + /** Minimum log level. Defaults to "info". */ 27 27 + level?: LogLevel; 28 28 + } 29 29 + 30 30 + /** Structured logger interface. */ 31 31 + export interface Logger { 32 32 + debug(message: string, attributes?: LogAttributes): void; 33 33 + info(message: string, attributes?: LogAttributes): void; 34 34 + warn(message: string, attributes?: LogAttributes): void; 35 35 + error(message: string, attributes?: LogAttributes): void; 36 36 + fatal(message: string, attributes?: LogAttributes): void; 37 37 + /** Create a child logger with additional base attributes. */ 38 38 + child(attributes: LogAttributes): Logger; 39 39 + /** Shut down the underlying OTel LoggerProvider and release its resources. */ 40 40 + shutdown(): Promise<void>; 41 41 + }

+8

packages/logger/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../tsconfig.base.json", 3 3 + "compilerOptions": { 4 4 + "outDir": "./dist", 5 5 + "rootDir": "./src" 6 6 + }, 7 7 + "include": ["src/**/*.ts"] 8 8 + }

+7

packages/logger/vitest.config.ts

··· 1 1 + import { defineConfig } from "vitest/config"; 2 2 + 3 3 + export default defineConfig({ 4 4 + test: { 5 5 + environment: "node", 6 6 + }, 7 7 + });

+133 -6

pnpm-lock.yaml

··· 22 22 version: 5.9.3 23 23 vitest: 24 24 specifier: ^4.0.18 25 25 - version: 4.0.18(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2) 25 25 + version: 4.0.18(@opentelemetry/api@1.9.0)(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2) 26 26 27 27 apps/appview: 28 28 dependencies: ··· 35 35 '@atbb/lexicon': 36 36 specifier: workspace:* 37 37 version: link:../../packages/lexicon 38 38 + '@atbb/logger': 39 39 + specifier: workspace:* 40 40 + version: link:../../packages/logger 38 41 '@atproto/api': 39 42 specifier: ^0.15.0 40 43 version: 0.15.27 ··· 58 61 version: 0.31.8 59 62 drizzle-orm: 60 63 specifier: ^0.45.1 61 61 - version: 0.45.1(postgres@3.4.8) 64 64 + version: 0.45.1(@opentelemetry/api@1.9.0)(postgres@3.4.8) 62 65 hono: 63 66 specifier: ^4.7.0 64 67 version: 4.11.8 ··· 87 90 88 91 apps/web: 89 92 dependencies: 93 93 + '@atbb/logger': 94 94 + specifier: workspace:* 95 95 + version: link:../../packages/logger 90 96 '@hono/node-server': 91 97 specifier: ^1.14.0 92 98 version: 1.19.9(hono@4.11.8) ··· 109 115 110 116 packages/atproto: 111 117 dependencies: 118 118 + '@atbb/logger': 119 119 + specifier: workspace:* 120 120 + version: link:../logger 112 121 '@atproto/api': 113 122 specifier: ^0.15.0 114 123 version: 0.15.27 ··· 128 137 '@atbb/db': 129 138 specifier: workspace:* 130 139 version: link:../db 140 140 + '@atbb/logger': 141 141 + specifier: workspace:* 142 142 + version: link:../logger 131 143 '@atproto/api': 132 144 specifier: ^0.15.0 133 145 version: 0.15.27 ··· 142 154 version: 3.4.2 143 155 drizzle-orm: 144 156 specifier: ^0.45.1 145 145 - version: 0.45.1(postgres@3.4.8) 157 157 + version: 0.45.1(@opentelemetry/api@1.9.0)(postgres@3.4.8) 146 158 postgres: 147 159 specifier: ^3.4.8 148 160 version: 3.4.8 ··· 164 176 dependencies: 165 177 drizzle-orm: 166 178 specifier: ^0.45.1 167 167 - version: 0.45.1(postgres@3.4.8) 179 179 + version: 0.45.1(@opentelemetry/api@1.9.0)(postgres@3.4.8) 168 180 postgres: 169 181 specifier: ^3.4.8 170 182 version: 3.4.8 ··· 212 224 yaml: 213 225 specifier: ^2.7.0 214 226 version: 2.8.2 227 227 + 228 228 + packages/logger: 229 229 + dependencies: 230 230 + '@opentelemetry/api': 231 231 + specifier: ^1.9.0 232 232 + version: 1.9.0 233 233 + '@opentelemetry/api-logs': 234 234 + specifier: ^0.200.0 235 235 + version: 0.200.0 236 236 + '@opentelemetry/core': 237 237 + specifier: ^2.0.0 238 238 + version: 2.5.1(@opentelemetry/api@1.9.0) 239 239 + '@opentelemetry/resources': 240 240 + specifier: ^2.0.0 241 241 + version: 2.5.1(@opentelemetry/api@1.9.0) 242 242 + '@opentelemetry/sdk-logs': 243 243 + specifier: ^0.200.0 244 244 + version: 0.200.0(@opentelemetry/api@1.9.0) 245 245 + '@opentelemetry/semantic-conventions': 246 246 + specifier: ^1.34.0 247 247 + version: 1.39.0 248 248 + hono: 249 249 + specifier: ^4.7.0 250 250 + version: 4.11.8 251 251 + devDependencies: 252 252 + '@types/node': 253 253 + specifier: ^22.0.0 254 254 + version: 22.19.9 255 255 + typescript: 256 256 + specifier: ^5.7.0 257 257 + version: 5.9.3 258 258 + vitest: 259 259 + specifier: ^3.1.0 260 260 + version: 3.2.4(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2) 215 261 216 262 packages: 217 263 ··· 927 973 '@jridgewell/sourcemap-codec@1.5.5': 928 974 resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==} 929 975 976 976 + '@opentelemetry/api-logs@0.200.0': 977 977 + resolution: {integrity: sha512-IKJBQxh91qJ+3ssRly5hYEJ8NDHu9oY/B1PXVSCWf7zytmYO9RNLB0Ox9XQ/fJ8m6gY6Q6NtBWlmXfaXt5Uc4Q==} 978 978 + engines: {node: '>=8.0.0'} 979 979 + 980 980 + '@opentelemetry/api@1.9.0': 981 981 + resolution: {integrity: sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==} 982 982 + engines: {node: '>=8.0.0'} 983 983 + 984 984 + '@opentelemetry/core@2.0.0': 985 985 + resolution: {integrity: sha512-SLX36allrcnVaPYG3R78F/UZZsBsvbc7lMCLx37LyH5MJ1KAAZ2E3mW9OAD3zGz0G8q/BtoS5VUrjzDydhD6LQ==} 986 986 + engines: {node: ^18.19.0 || >=20.6.0} 987 987 + peerDependencies: 988 988 + '@opentelemetry/api': '>=1.0.0 <1.10.0' 989 989 + 990 990 + '@opentelemetry/core@2.5.1': 991 991 + resolution: {integrity: sha512-Dwlc+3HAZqpgTYq0MUyZABjFkcrKTePwuiFVLjahGD8cx3enqihmpAmdgNFO1R4m/sIe5afjJrA25Prqy4NXlA==} 992 992 + engines: {node: ^18.19.0 || >=20.6.0} 993 993 + peerDependencies: 994 994 + '@opentelemetry/api': '>=1.0.0 <1.10.0' 995 995 + 996 996 + '@opentelemetry/resources@2.0.0': 997 997 + resolution: {integrity: sha512-rnZr6dML2z4IARI4zPGQV4arDikF/9OXZQzrC01dLmn0CZxU5U5OLd/m1T7YkGRj5UitjeoCtg/zorlgMQcdTg==} 998 998 + engines: {node: ^18.19.0 || >=20.6.0} 999 999 + peerDependencies: 1000 1000 + '@opentelemetry/api': '>=1.3.0 <1.10.0' 1001 1001 + 1002 1002 + '@opentelemetry/resources@2.5.1': 1003 1003 + resolution: {integrity: sha512-BViBCdE/GuXRlp9k7nS1w6wJvY5fnFX5XvuEtWsTAOQFIO89Eru7lGW3WbfbxtCuZ/GbrJfAziXG0w0dpxL7eQ==} 1004 1004 + engines: {node: ^18.19.0 || >=20.6.0} 1005 1005 + peerDependencies: 1006 1006 + '@opentelemetry/api': '>=1.3.0 <1.10.0' 1007 1007 + 1008 1008 + '@opentelemetry/sdk-logs@0.200.0': 1009 1009 + resolution: {integrity: sha512-VZG870063NLfObmQQNtCVcdXXLzI3vOjjrRENmU37HYiPFa0ZXpXVDsTD02Nh3AT3xYJzQaWKl2X2lQ2l7TWJA==} 1010 1010 + engines: {node: ^18.19.0 || >=20.6.0} 1011 1011 + peerDependencies: 1012 1012 + '@opentelemetry/api': '>=1.4.0 <1.10.0' 1013 1013 + 1014 1014 + '@opentelemetry/semantic-conventions@1.39.0': 1015 1015 + resolution: {integrity: sha512-R5R9tb2AXs2IRLNKLBJDynhkfmx7mX0vi8NkhZb3gUkPWHn6HXk5J8iQ/dql0U3ApfWym4kXXmBDRGO+oeOfjg==} 1016 1016 + engines: {node: '>=14'} 1017 1017 + 930 1018 '@oxlint/darwin-arm64@0.17.0': 931 1019 resolution: {integrity: sha512-py/N0yTMbdy5Kd1RFMMgFqzO5Qwc5MbHSCA0BvSx/GnC3n7yPstcEFSSdZzb+HaANI00xn4dwjYo6HVEFHhuWA==} 932 1020 cpu: [arm64] ··· 2575 2663 2576 2664 '@jridgewell/sourcemap-codec@1.5.5': {} 2577 2665 2666 2666 + '@opentelemetry/api-logs@0.200.0': 2667 2667 + dependencies: 2668 2668 + '@opentelemetry/api': 1.9.0 2669 2669 + 2670 2670 + '@opentelemetry/api@1.9.0': {} 2671 2671 + 2672 2672 + '@opentelemetry/core@2.0.0(@opentelemetry/api@1.9.0)': 2673 2673 + dependencies: 2674 2674 + '@opentelemetry/api': 1.9.0 2675 2675 + '@opentelemetry/semantic-conventions': 1.39.0 2676 2676 + 2677 2677 + '@opentelemetry/core@2.5.1(@opentelemetry/api@1.9.0)': 2678 2678 + dependencies: 2679 2679 + '@opentelemetry/api': 1.9.0 2680 2680 + '@opentelemetry/semantic-conventions': 1.39.0 2681 2681 + 2682 2682 + '@opentelemetry/resources@2.0.0(@opentelemetry/api@1.9.0)': 2683 2683 + dependencies: 2684 2684 + '@opentelemetry/api': 1.9.0 2685 2685 + '@opentelemetry/core': 2.0.0(@opentelemetry/api@1.9.0) 2686 2686 + '@opentelemetry/semantic-conventions': 1.39.0 2687 2687 + 2688 2688 + '@opentelemetry/resources@2.5.1(@opentelemetry/api@1.9.0)': 2689 2689 + dependencies: 2690 2690 + '@opentelemetry/api': 1.9.0 2691 2691 + '@opentelemetry/core': 2.5.1(@opentelemetry/api@1.9.0) 2692 2692 + '@opentelemetry/semantic-conventions': 1.39.0 2693 2693 + 2694 2694 + '@opentelemetry/sdk-logs@0.200.0(@opentelemetry/api@1.9.0)': 2695 2695 + dependencies: 2696 2696 + '@opentelemetry/api': 1.9.0 2697 2697 + '@opentelemetry/api-logs': 0.200.0 2698 2698 + '@opentelemetry/core': 2.0.0(@opentelemetry/api@1.9.0) 2699 2699 + '@opentelemetry/resources': 2.0.0(@opentelemetry/api@1.9.0) 2700 2700 + 2701 2701 + '@opentelemetry/semantic-conventions@1.39.0': {} 2702 2702 + 2578 2703 '@oxlint/darwin-arm64@0.17.0': 2579 2704 optional: true 2580 2705 ··· 2879 3004 transitivePeerDependencies: 2880 3005 - supports-color 2881 3006 2882 2882 - drizzle-orm@0.45.1(postgres@3.4.8): 3007 3007 + drizzle-orm@0.45.1(@opentelemetry/api@1.9.0)(postgres@3.4.8): 2883 3008 optionalDependencies: 3009 3009 + '@opentelemetry/api': 1.9.0 2884 3010 postgres: 3.4.8 2885 3011 2886 3012 emoji-regex@8.0.0: {} ··· 3454 3580 - tsx 3455 3581 - yaml 3456 3582 3457 3457 - vitest@4.0.18(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2): 3583 3583 + vitest@4.0.18(@opentelemetry/api@1.9.0)(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2): 3458 3584 dependencies: 3459 3585 '@vitest/expect': 4.0.18 3460 3586 '@vitest/mocker': 4.0.18(vite@7.3.1(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2)) ··· 3477 3603 vite: 7.3.1(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2) 3478 3604 why-is-node-running: 2.3.0 3479 3605 optionalDependencies: 3606 3606 + '@opentelemetry/api': 1.9.0 3480 3607 '@types/node': 22.19.9 3481 3608 transitivePeerDependencies: 3482 3609 - jiti

+1 -1

turbo.json

··· 19 19 }, 20 20 "test": { 21 21 "dependsOn": ["^build"], 22 22 - "env": ["DATABASE_URL", "BACKFILL_RATE_LIMIT", "BACKFILL_CONCURRENCY", "BACKFILL_CURSOR_MAX_AGE_HOURS"] 22 22 + "env": ["DATABASE_URL", "LOG_LEVEL", "BACKFILL_RATE_LIMIT", "BACKFILL_CONCURRENCY", "BACKFILL_CURSOR_MAX_AGE_HOURS"] 23 23 }, 24 24 "clean": { 25 25 "cache": false