Add output logging channel for debug logs

Author: savannahostrowski

src/core/analyzer.ts

@@ -4,6 +4,7 @@
 
 import { readFileSync } from "node:fs"
 import type { Tree } from "web-tree-sitter"
+import { logError } from "../utils/logger"
 import {
   decoratorExtractor,
   findNodesByType,
@@ -55,10 +56,12 @@ export function analyzeFile(
     const code = readFileSync(filePath, "utf-8")
     const tree = parser.parse(code)
     if (!tree) {
+      logError(`Failed to parse file: "${filePath}"`)
       return null
     }
     return analyzeTree(tree, filePath)
-  } catch {
+  } catch (error) {
+    logError(`Error reading file: "${filePath}"`, error)
     return null
   }
 }

src/core/routerResolver.ts

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs"
 import { isAbsolute, join } from "node:path"
+import { log } from "../utils/logger"
 import { analyzeFile } from "./analyzer"
 import { resolveNamedImport, resolveRouterFromInit } from "./importResolver"
 import type { FileAnalysis, RouterInfo, RouterNode } from "./internal"
@@ -46,10 +47,12 @@ function buildRouterGraphInternal(
   }
 
   if (!existsSync(resolvedEntryFile)) {
+    log(`File not found: "${entryFile}"`)
     return null
   }
   // Prevent infinite recursion on circular imports
   if (visited.has(resolvedEntryFile)) {
+    log(`Skipping already visited file: "${resolvedEntryFile}"`)
     return null
   }
 
@@ -58,9 +61,14 @@ function buildRouterGraphInternal(
   // Analyze the entry file
   let analysis = analyzeFile(resolvedEntryFile, parser)
   if (!analysis) {
+    log(`Failed to analyze file: "${resolvedEntryFile}"`)
     return null
   }
 
+  log(
+    `Analyzed "${resolvedEntryFile}": ${analysis.routes.length} routes, ${analysis.routers.length} routers, ${analysis.includeRouters.length} include_router calls`,
+  )
+
   // Find FastAPI instantiation
   let appRouter = findAppRouter(analysis.routers)
 
@@ -114,6 +122,9 @@ function buildRouterGraphInternal(
 
   // Process include_router calls to find child routers
   for (const include of analysis.includeRouters) {
+    log(
+      `Resolving include_router: ${include.router} (prefix: ${include.prefix || "none"})`,
+    )
     const childRouter = resolveRouterReference(
       include.router,
       analysis,
@@ -204,6 +215,7 @@ function resolveRouterReference(
   )
 
   if (!matchingImport) {
+    log(`No import found for router reference: ${reference}`)
     return null
   }
 
@@ -220,6 +232,7 @@ function resolveRouterReference(
   )
 
   if (!importedFilePath) {
+    log(`Could not resolve import: ${matchingImport.modulePath}`)
     return null
   }
 

src/extension.ts

@@ -3,7 +3,7 @@
  */
 
 import { existsSync } from "node:fs"
-import { sep } from "node:path"
+import { basename, sep } from "node:path"
 import * as vscode from "vscode"
 import { clearImportCache } from "./core/importResolver"
 import { Parser } from "./core/parser"
@@ -16,15 +16,21 @@ import {
   EndpointTreeProvider,
 } from "./providers/EndpointTreeProvider"
 import { TestCodeLensProvider } from "./providers/TestCodeLensProvider"
+import { disposeLogger, log } from "./utils/logger"
 
 async function discoverFastAPIApps(parser: Parser): Promise<AppDefinition[]> {
   const apps: AppDefinition[] = []
   const workspaceFolders = vscode.workspace.workspaceFolders
 
   if (!workspaceFolders) {
+    log("No workspace folders found")
     return apps
   }
 
+  log(
+    `Discovering FastAPI apps in ${workspaceFolders.length} workspace folder(s)...`,
+  )
+
   for (const folder of workspaceFolders) {
     const config = vscode.workspace.getConfiguration("fastapi", folder.uri)
     const customEntryPoint = config.get<string>("entryPoint")
@@ -38,12 +44,14 @@ async function discoverFastAPIApps(parser: Parser): Promise<AppDefinition[]> {
         : vscode.Uri.joinPath(folder.uri, customEntryPoint).fsPath
 
       if (!existsSync(entryPath)) {
+        log(`Custom entry point not found: ${customEntryPoint}`)
         vscode.window.showWarningMessage(
           `FastAPI entry point not found: ${customEntryPoint}`,
         )
         continue
       }
 
+      log(`Using custom entry point: ${customEntryPoint}`)
       candidates = [entryPath]
     } else {
       // Scan for main.py and __init__.py files (likely FastAPI entry points)
@@ -57,19 +65,37 @@ async function discoverFastAPIApps(parser: Parser): Promise<AppDefinition[]> {
       candidates = [...mainFiles, ...initFiles]
         .map((uri) => uri.fsPath)
         .sort((a, b) => a.split(sep).length - b.split(sep).length)
+      log(
+        `Found ${candidates.length} candidate entry file(s) in ${basename(folder.uri.fsPath)}`,
+      )
     }
 
     for (const entryPath of candidates) {
       const projectRoot = findProjectRoot(entryPath, folder.uri.fsPath)
       const routerNode = buildRouterGraph(entryPath, parser, projectRoot)
 
       if (routerNode) {
-        apps.push(routerNodeToAppDefinition(routerNode, folder.uri.fsPath))
+        const app = routerNodeToAppDefinition(routerNode, folder.uri.fsPath)
+        apps.push(app)
+        // Count all routes: direct routes + routes in all routers (recursively)
+        const countRoutes = (routers: typeof app.routers): number =>
+          routers.reduce(
+            (sum, r) => sum + r.routes.length + countRoutes(r.children),
+            0,
+          )
+        const totalRoutes = app.routes.length + countRoutes(app.routers)
+        log(
+          `Found FastAPI app "${app.name}" with ${totalRoutes} route(s) in ${app.routers.length} router(s)`,
+        )
         break
       }
     }
   }
 
+  if (apps.length === 0) {
+    log("No FastAPI apps found in workspace")
+  }
+
   return apps
 }
 
@@ -84,6 +110,13 @@ function navigateToLocation(location: SourceLocation): void {
 let parserService: Parser | null = null
 
 export async function activate(context: vscode.ExtensionContext) {
+  const extensionVersion =
+    vscode.extensions.getExtension("FastAPILabs.fastapi-vscode")?.packageJSON
+      ?.version ?? "unknown"
+  log(
+    `FastAPI extension ${extensionVersion} activated (VS Code ${vscode.version})`,
+  )
+
   parserService = new Parser()
   await parserService.init({
     core: vscode.Uri.joinPath(
@@ -223,7 +256,9 @@ export async function activate(context: vscode.ExtensionContext) {
 }
 
 export function deactivate() {
+  log("Extension deactivated")
   parserService?.dispose()
   parserService = null
   clearImportCache()
+  disposeLogger()
 }

src/utils/logger.ts

@@ -0,0 +1,36 @@
+/**
+ * Output channel logger for the FastAPI extension.
+ * Provides visibility into extension activity for troubleshooting.
+ *
+ * Uses LogOutputChannel for colored log levels and automatic timestamps.
+ */
+
+import * as vscode from "vscode"
+
+let outputChannel: vscode.LogOutputChannel | null = null
+
+function getOutputChannel(): vscode.LogOutputChannel {
+  if (!outputChannel) {
+    outputChannel = vscode.window.createOutputChannel("FastAPI", { log: true })
+  }
+  return outputChannel
+}
+
+export function log(message: string): void {
+  getOutputChannel().info(message)
+}
+
+export function logError(message: string, error?: unknown): void {
+  if (error instanceof Error) {
+    getOutputChannel().error(`${message}: ${error.message}`)
+  } else if (error !== undefined) {
+    getOutputChannel().error(`${message}: ${String(error)}`)
+  } else {
+    getOutputChannel().error(message)
+  }
+}
+
+export function disposeLogger(): void {
+  outputChannel?.dispose()
+  outputChannel = null
+}