feat: add logs:edge-functions command and historical log support

docs/commands/logs.md

@@ -24,6 +24,7 @@
 | Subcommand | description  |
 |:--------------------------- |:-----|
 | [`logs:deploy`](/commands/logs#logsdeploy) | Stream the logs of deploys currently being built to the console  |
+| [`logs:edge-functions`](/commands/logs#logsedge-functions) | Stream netlify edge function logs to the console  |
 | [`logs:function`](/commands/logs#logsfunction) | Stream netlify function logs to the console  |
 
 
@@ -33,6 +34,8 @@
 netlify logs:deploy
 netlify logs:function
 netlify logs:function my-function
+netlify logs:edge-functions
+netlify logs:edge-functions --deploy-id <deploy-id>
 ```
 
 ---
@@ -52,6 +55,37 @@
 - `debug` (*boolean*) - Print debugging information
 - `auth` (*string*) - Netlify auth token - can be used to run this command without logging in
 
+---
+## `logs:edge-functions`
+
+Stream netlify edge function logs to the console
+
+**Usage**
+
+```bash
+netlify logs:edge-functions
+```
+
+**Flags**
+
+- `deploy-id` (*string*) - Deploy ID to stream edge function logs for
+- `filter` (*string*) - For monorepos, specify the name of the application to run the command in
+- `from` (*string*) - Start date for historical logs (ISO 8601 format)
+- `level` (*string*) - Log levels to stream. Choices are: trace, debug, info, warn, error, fatal
+- `debug` (*boolean*) - Print debugging information
+- `auth` (*string*) - Netlify auth token - can be used to run this command without logging in
+- `to` (*string*) - End date for historical logs (ISO 8601 format, defaults to now)
+
+**Examples**
+
+```bash
+netlify logs:edge-functions
+netlify logs:edge-functions --deploy-id <deploy-id>
+netlify logs:edge-functions --from 2026-01-01T00:00:00Z
+netlify logs:edge-functions --from 2026-01-01T00:00:00Z --to 2026-01-02T00:00:00Z
+netlify logs:edge-functions -l info warn
+```
+
 ---
 ## `logs:function`
 
@@ -65,21 +99,27 @@
 
 **Arguments**
 
-- functionName - Name of the function to stream logs for
+- functionName - Name or ID of the function to stream logs for
 
 **Flags**
 
+- `deploy-id` (*string*) - Deploy ID to look up the function from
 - `filter` (*string*) - For monorepos, specify the name of the application to run the command in
+- `from` (*string*) - Start date for historical logs (ISO 8601 format)
 - `level` (*string*) - Log levels to stream. Choices are: trace, debug, info, warn, error, fatal
 - `debug` (*boolean*) - Print debugging information
 - `auth` (*string*) - Netlify auth token - can be used to run this command without logging in
+- `to` (*string*) - End date for historical logs (ISO 8601 format, defaults to now)
 
 **Examples**
 
 ```bash
 netlify logs:function
 netlify logs:function my-function
+netlify logs:function my-function --deploy-id <deploy-id>
 netlify logs:function my-function -l info warn
+netlify logs:function my-function --from 2026-01-01T00:00:00Z
+netlify logs:function my-function --from 2026-01-01T00:00:00Z --to 2026-01-02T00:00:00Z
 ```
 
 ---

docs/index.md

@@ -132,6 +132,7 @@ Stream logs from your project
 | Subcommand | description  |
 |:--------------------------- |:-----|
 | [`logs:deploy`](/commands/logs#logsdeploy) | Stream the logs of deploys currently being built to the console  |
+| [`logs:edge-functions`](/commands/logs#logsedge-functions) | Stream netlify edge function logs to the console  |
 | [`logs:function`](/commands/logs#logsfunction) | Stream netlify function logs to the console  |
 
 

src/commands/deploy/deploy.ts

@@ -551,6 +551,8 @@ const runDeploy = async ({
   functionLogsUrl: string
   edgeFunctionLogsUrl: string
   sourceZipFileName?: string
+  deployedFunctions: { name: string; id: string }[]
+  hasEdgeFunctions: boolean
 }> => {
   let results
   let deployId = existingDeployId
@@ -662,6 +664,13 @@ const runDeploy = async ({
     edgeFunctionLogsUrl += `?scope=deployid:${deployId}`
   }
 
+  const availableFunctions = (results.deploy.available_functions ?? []) as { n?: string; oid?: string }[]
+  const deployedFunctions = availableFunctions
+    .filter((fn): fn is { n: string; oid: string } => Boolean(fn.n && fn.oid))
+    .map((fn) => ({ name: fn.n, id: fn.oid }))
+
+  const hasEdgeFunctions = (results.edgeFunctionsCount ?? 0) > 0
+
   return {
     siteId: results.deploy.site_id,
     siteName: results.deploy.name,
@@ -672,6 +681,8 @@ const runDeploy = async ({
     functionLogsUrl,
     edgeFunctionLogsUrl,
     sourceZipFileName: uploadSourceZipResult?.sourceZipFileName,
+    deployedFunctions,
+    hasEdgeFunctions,
   }
 }
 
@@ -779,6 +790,7 @@ interface JsonData {
   logs: string
   function_logs: string
   edge_function_logs: string
+  deployed_functions: { name: string; id: string }[]
   url?: string
   source_zip_filename?: string
 }
@@ -796,10 +808,18 @@ const printResults = ({
   results: Awaited<ReturnType<typeof prepAndRunDeploy>>
   runBuildCommand: boolean
 }): void => {
-  const msgData: Record<string, string> = {
+  const buildLogsData: Record<string, string> = {
     'Build logs': terminalLink(results.logsUrl, results.logsUrl, { fallback: false }),
+  }
+
+  const functionLogsData: Record<string, string> = {
     'Function logs': terminalLink(results.functionLogsUrl, results.functionLogsUrl, { fallback: false }),
-    'Edge function Logs': terminalLink(results.edgeFunctionLogsUrl, results.edgeFunctionLogsUrl, { fallback: false }),
+    'Function CLI': `netlify logs:function --deploy-id ${results.deployId} <function-name>`,
+  }
+
+  const edgeFunctionLogsData: Record<string, string> = {
+    'Edge function logs': terminalLink(results.edgeFunctionLogsUrl, results.edgeFunctionLogsUrl, { fallback: false }),
+    'Edge function CLI': `netlify logs:edge-functions --deploy-id ${results.deployId}`,
   }
 
   log('')
@@ -816,6 +836,7 @@ const printResults = ({
       logs: results.logsUrl,
       function_logs: results.functionLogsUrl,
       edge_function_logs: results.edgeFunctionLogsUrl,
+      deployed_functions: results.deployedFunctions,
     }
     if (deployToProduction) {
       jsonData.url = results.siteUrl
@@ -847,7 +868,22 @@ const printResults = ({
       }),
     )
 
-    log(prettyjson.render(msgData))
+    log(prettyjson.render(buildLogsData))
+
+    if (results.deployedFunctions.length > 0) {
+      log()
+      log(prettyjson.render(functionLogsData))
+    }
+
+    if (results.hasEdgeFunctions) {
+      log()
+      log(prettyjson.render(edgeFunctionLogsData))
+    }
+
+    if (results.deployedFunctions.length > 0 || results.hasEdgeFunctions) {
+      log()
+      log(chalk.dim('Use --from <datetime> and --to <datetime> to fetch historical logs (ISO 8601 format)'))
+    }
 
     if (!deployToProduction) {
       log()

src/commands/logs/edge-functions.ts

@@ -0,0 +1,98 @@
+import { OptionValues } from 'commander'
+import inquirer from 'inquirer'
+
+import { chalk, log } from '../../utils/command-helpers.js'
+import { getWebSocket } from '../../utils/websockets/index.js'
+import type BaseCommand from '../base-command.js'
+
+import { parseDateToMs, fetchHistoricalLogs, printHistoricalLogs, formatLogEntry } from './log-api.js'
+import { CLI_LOG_LEVEL_CHOICES_STRING, LOG_LEVELS_LIST } from './log-levels.js'
+import { getName } from './build.js'
+
+export const logsEdgeFunction = async (options: OptionValues, command: BaseCommand) => {
+  let deployId = options.deployId as string | undefined
+  await command.authenticate()
+
+  const client = command.netlify.api
+  const { site } = command.netlify
+  const { id: siteId } = site
+
+  if (!siteId) {
+    log('You must link a project before attempting to view edge function logs')
+    return
+  }
+
+  const levels = options.level as string[] | undefined
+  if (levels && !levels.every((level) => LOG_LEVELS_LIST.includes(level))) {
+    log(`Invalid log level. Choices are:${CLI_LOG_LEVEL_CHOICES_STRING.toString()}`)
+  }
+
+  const levelsToPrint: string[] = levels || LOG_LEVELS_LIST
+
+  if (options.from) {
+    const fromMs = parseDateToMs(options.from as string)
+    const toMs = options.to ? parseDateToMs(options.to as string) : Date.now()
+
+    const url = `https://analytics.services.netlify.com/v2/sites/${siteId}/edge_function_logs?from=${fromMs.toString()}&to=${toMs.toString()}`
+    const data = await fetchHistoricalLogs({ url, accessToken: client.accessToken ?? '' })
+    printHistoricalLogs(data, levelsToPrint)
+    return
+  }
+
+  const userId = command.netlify.globalConfig.get('userId') as string
+
+  if (!deployId) {
+    const deploys = await client.listSiteDeploys({ siteId })
+
+    if (deploys.length === 0) {
+      log('No deploys found for the project')
+      return
+    }
+
+    if (deploys.length === 1) {
+      deployId = deploys[0].id
+    } else {
+      const { result } = (await inquirer.prompt({
+        name: 'result',
+        type: 'list',
+        message: `Select a deploy\n\n${chalk.yellow('*')} indicates a deploy created by you`,
+        choices: deploys.map((deploy) => ({
+          name: getName({ deploy, userId }),
+          value: deploy.id,
+        })),
+      })) as { result: string }
+
+      deployId = result
+    }
+  }
+
+  const ws = getWebSocket('wss://socketeer.services.netlify.com/edge-function/logs')
+
+  ws.on('open', () => {
+    ws.send(
+      JSON.stringify({
+        deploy_id: deployId,
+        site_id: siteId,
+        access_token: client.accessToken,
+        since: new Date().toISOString(),
+      }),
+    )
+  })
+
+  ws.on('message', (data: string) => {
+    const logData = JSON.parse(data) as { level: string; message: string; timestamp?: string }
+    if (!levelsToPrint.includes(logData.level.toLowerCase())) {
+      return
+    }
+    log(formatLogEntry(logData))
+  })
+
+  ws.on('close', () => {
+    log('Connection closed')
+  })
+
+  ws.on('error', (err: Error) => {
+    log('Connection error')
+    log(err.message)
+  })
+}

src/commands/logs/functions.ts

@@ -5,6 +5,7 @@ import { chalk, log } from '../../utils/command-helpers.js'
 import { getWebSocket } from '../../utils/websockets/index.js'
 import type BaseCommand from '../base-command.js'
 
+import { parseDateToMs, fetchHistoricalLogs, printHistoricalLogs } from './log-api.js'
 import { CLI_LOG_LEVEL_CHOICES_STRING, LOG_LEVELS, LOG_LEVELS_LIST } from './log-levels.js'
 
 function getLog(logData: { level: string; message: string }) {
@@ -28,8 +29,10 @@ function getLog(logData: { level: string; message: string }) {
 }
 
 export const logsFunction = async (functionName: string | undefined, options: OptionValues, command: BaseCommand) => {
+  await command.authenticate()
+
   const client = command.netlify.api
-  const { site } = command.netlify
+  const { site, siteInfo } = command.netlify
   const { id: siteId } = site
 
   if (options.level && !options.level.every((level: string) => LOG_LEVELS_LIST.includes(level))) {
@@ -38,17 +41,24 @@ export const logsFunction = async (functionName: string | undefined, options: Op
 
   const levelsToPrint = options.level || LOG_LEVELS_LIST
 
-  // TODO: Update type once the open api spec is updated https://open-api.netlify.com/#tag/function/operation/searchSiteFunctions
-  const { functions = [] } = (await client.searchSiteFunctions({ siteId: siteId! })) as any
+  let functions: any[]
+  if (options.deployId) {
+    const deploy = (await client.getSiteDeploy({ siteId: siteId!, deployId: options.deployId })) as any
+    functions = deploy.available_functions ?? []
+  } else {
+    // TODO: Update type once the open api spec is updated https://open-api.netlify.com/#tag/function/operation/searchSiteFunctions
+    const result = (await client.searchSiteFunctions({ siteId: siteId! })) as any
+    functions = result.functions ?? []
+  }
 
   if (functions.length === 0) {
-    log(`No functions found for the project`)
+    log(`No functions found for the ${options.deployId ? 'deploy' : 'project'}`)
     return
   }
 
   let selectedFunction
   if (functionName) {
-    selectedFunction = functions.find((fn: any) => fn.n === functionName)
+    selectedFunction = functions.find((fn: any) => fn.n === functionName || fn.oid === functionName)
   } else {
     const { result } = await inquirer.prompt({
       name: 'result',
@@ -65,7 +75,18 @@ export const logsFunction = async (functionName: string | undefined, options: Op
     return
   }
 
-  const { a: accountId, oid: functionId } = selectedFunction
+  const { a: accountId, n: resolvedFunctionName, oid: functionId } = selectedFunction
+
+  if (options.from) {
+    const fromMs = parseDateToMs(options.from)
+    const toMs = options.to ? parseDateToMs(options.to) : Date.now()
+    const branch = siteInfo.build_settings?.repo_branch ?? 'main'
+
+    const url = `https://analytics.services.netlify.com/v2/sites/${siteId}/branch/${branch}/function_logs/${resolvedFunctionName}?from=${fromMs.toString()}&to=${toMs.toString()}`
+    const data = await fetchHistoricalLogs({ url, accessToken: client.accessToken ?? '' })
+    printHistoricalLogs(data, levelsToPrint)
+    return
+  }
 
   const ws = getWebSocket('wss://socketeer.services.netlify.com/function/logs')