Add logging to project automations

.github/workflows/issue_automations.yml

@@ -31,4 +31,4 @@ jobs:
           github-token: ${{ secrets.ACCESS_TOKEN }}
           script: |
             const { main } = await import('${{ github.workspace }}/automations/js/src/project_automation/issues.mjs')
-            await main(github, context)
+            await main(github, core, context)

.github/workflows/pr_automations.yml

@@ -71,4 +71,4 @@ jobs:
           github-token: ${{ secrets.ACCESS_TOKEN }}
           script: |
             const { main } = await import('${{ github.workspace }}/automations/js/src/project_automation/prs.mjs')
-            await main(github)
+            await main(github, core)

automations/js/src/project_automation/issues.mjs

@@ -7,85 +7,113 @@ import { getBoard } from '../utils/projects.mjs'
  * @param issue {import('@octokit/rest')}
  * @param board {import('../utils/projects.mjs').Project}
  * @param card {import('../utils/projects.mjs').Card}
+ * @param core {import('@actions/core')} for logging
  */
-async function syncPriority(issue, board, card) {
+async function syncPriority(issue, board, card, core) {
+  core.debug(`Starting syncPriority for issue: ${issue.number}`)
   const priority = issue.labels.find((label) =>
     label.name.includes('priority')
   )?.name
+
   if (priority) {
-    await board.setCustomChoiceField(card.id, 'Priority', priority)
+    await board.setCustomChoiceField(card.id, 'Priority', priority, core)
   }
   if (priority === '🟥 priority: critical') {
-    await board.moveCard(card.id, board.columns.ToDo)
+    await board.moveCard(card.id, board.columns.ToDo, core)
   }
 }
 
 /**
  * This is the entrypoint of the script.
  *
  * @param octokit {import('@octokit/rest').Octokit} the Octokit instance to use
+ * @param core {import('@actions/core')} GitHub Actions toolkit, for logging
  * @param context {import('@actions/github').context} info about the current event
  */
-export const main = async (octokit, context) => {
+export const main = async (octokit, core, context) => {
   const { EVENT_ACTION: eventAction } = process.env
 
+  core.debug(`Event action received: ${eventAction}`)
+
   const issue = context.payload.issue
   const label = context.payload.label
+  core.info('Issue details:', issue)
 
   if (issue.labels.some((label) => label.name === '🧭 project: thread')) {
-    // Do not add project threads to the Backlog board.
+    core.warning('Issue is a project thread. Exiting.')
     process.exit(0)
   }
 
-  const backlogBoard = await getBoard(octokit, 'Backlog')
+  await core.group('Processing Issue or PR', async () => {
+    core.debug('Getting instance for the project')
+    const backlogBoard = await getBoard(octokit, core, 'Backlog')
 
-  // Create new, or get the existing, card for the current issue.
-  const card = await backlogBoard.addCard(issue.node_id)
+    core.debug('Adding the issue or PR to the project')
+    const card = await backlogBoard.addCard(issue.node_id)
 
-  switch (eventAction) {
-    case 'opened':
-    case 'reopened': {
-      if (issue.labels.some((label) => label.name === '⛔ status: blocked')) {
-        await backlogBoard.moveCard(card.id, backlogBoard.columns.Blocked)
-      } else {
-        await backlogBoard.moveCard(card.id, backlogBoard.columns.Backlog)
-      }
-
-      await syncPriority(issue, backlogBoard, card)
-      break
-    }
+    switch (eventAction) {
+      case 'opened':
+      case 'reopened':
+        core.info('Issue opened or reopened')
+        if (issue.labels.some((label) => label.name === '⛔ status: blocked')) {
+          await backlogBoard.moveCard(
+            card.id,
+            backlogBoard.columns.Blocked,
+            core
+          )
+        } else {
+          await backlogBoard.moveCard(
+            card.id,
+            backlogBoard.columns.Backlog,
+            core
+          )
+        }
+        await syncPriority(issue, backlogBoard, card, core)
+        break
 
-    case 'closed': {
-      if (issue.state_reason === 'completed') {
-        await backlogBoard.moveCard(card.id, backlogBoard.columns.Done)
-      } else {
-        await backlogBoard.moveCard(card.id, backlogBoard.columns.Discarded)
-      }
-      break
-    }
+      case 'closed':
+        core.info('Issue closed')
+        if (issue.state_reason === 'completed') {
+          await backlogBoard.moveCard(card.id, backlogBoard.columns.Done, core)
+        } else {
+          await backlogBoard.moveCard(
+            card.id,
+            backlogBoard.columns.Discarded,
+            core
+          )
+        }
+        break
 
-    case 'assigned': {
-      if (card.status === backlogBoard.columns.Backlog) {
-        await backlogBoard.moveCard(card.id, backlogBoard.columns.ToDo)
-      }
-      break
-    }
+      case 'assigned':
+        core.info('Issue assigned')
+        if (card.status === backlogBoard.columns.Backlog) {
+          await backlogBoard.moveCard(card.id, backlogBoard.columns.ToDo, core)
+        }
+        break
 
-    case 'labeled': {
-      if (label.name === '⛔ status: blocked') {
-        await backlogBoard.moveCard(card.id, backlogBoard.columns.Blocked)
-      }
-      await syncPriority(issue, backlogBoard, card)
-      break
-    }
+      case 'labeled':
+        core.info(`Issue labeled: ${label.name}`)
+        if (label.name === '⛔ status: blocked') {
+          await backlogBoard.moveCard(
+            card.id,
+            backlogBoard.columns.Blocked,
+            core
+          )
+        }
+        await syncPriority(issue, backlogBoard, card, core)
+        break
 
-    case 'unlabeled': {
-      if (label.name === '⛔ status: blocked') {
-        // TODO: Move back to the column it came from.
-        await backlogBoard.moveCard(card.id, backlogBoard.columns.Backlog)
-      }
-      await syncPriority(issue, backlogBoard, card)
-      break
+      case 'unlabeled':
+        core.info(`Label removed: ${label.name}`)
+        if (label.name === '⛔ status: blocked') {
+          await backlogBoard.moveCard(
+            card.id,
+            backlogBoard.columns.Backlog,
+            core
+          )
+        }
+        await syncPriority(issue, backlogBoard, card, core)
+        break
     }
-  }
+  })
 }

automations/js/src/project_automation/prs.mjs

@@ -3,97 +3,108 @@ import { readFileSync } from 'fs'
 import { getBoard } from '../utils/projects.mjs'
 import { PullRequest } from '../utils/pr.mjs'
 
-/**
- * Move the PR to the right column based on the number of reviews.
- *
- * @param pr {PullRequest}
- * @param prBoard {Project}
- * @param prCard {Card}
- */
-async function syncReviews(pr, prBoard, prCard) {
+async function syncReviews(pr, prBoard, prCard, core) {
+  core.debug(`Synchronizing reviews for PR: ${pr.nodeId}`)
   const reviewDecision = pr.reviewDecision
-  const reviewCounts = pr.reviewCounts
+  core.debug(`Review decision: ${reviewDecision}`)
 
-  if (reviewDecision === 'APPROVED') {
-    await prBoard.moveCard(prCard.id, prBoard.columns.Approved)
-  } else if (reviewDecision === 'CHANGES_REQUESTED') {
-    await prBoard.moveCard(prCard.id, prBoard.columns.ChangesRequested)
-  } else if (reviewCounts.APPROVED === 1) {
-    await prBoard.moveCard(prCard.id, prBoard.columns.Needs1Review)
-  } else {
-    await prBoard.moveCard(prCard.id, prBoard.columns.Needs2Reviews)
-  }
+  await core.group(
+    `Handling review decision for PR: ${pr.nodeId}`,
+    async () => {
+      if (reviewDecision === 'APPROVED') {
+        await prBoard.moveCard(prCard.id, prBoard.columns.Approved, core)
+      } else if (reviewDecision === 'CHANGES_REQUESTED') {
+        await prBoard.moveCard(
+          prCard.id,
+          prBoard.columns.ChangesRequested,
+          core
+        )
+      } else if (pr.reviewCounts.APPROVED === 1) {
+        await prBoard.moveCard(prCard.id, prBoard.columns.Needs1Review, core)
+      } else {
+        await prBoard.moveCard(prCard.id, prBoard.columns.Needs2Reviews, core)
+      }
+    }
+  )
 }
 
-/**
- * Move all linked issues to the specified column.
- *
- * @param pr {PullRequest}
- * @param backlogBoard {Project}
- * @param destColumn {string}
- */
-async function syncIssues(pr, backlogBoard, destColumn) {
+async function syncIssues(pr, backlogBoard, destColumn, core) {
+  core.debug(`Synchronizing linked issues for PR: ${pr.nodeId}`)
   for (let linkedIssue of pr.linkedIssues) {
-    const issueCard = await backlogBoard.addCard(linkedIssue)
-    await backlogBoard.moveCard(issueCard.id, backlogBoard.columns[destColumn])
+    await core.group(`Processing linked issue: ${linkedIssue}`, async () => {
+      core.debug('Adding linked issue to board')
+      const issueCard = await backlogBoard.addCard(linkedIssue)
+      await backlogBoard.moveCard(
+        issueCard.id,
+        backlogBoard.columns[destColumn],
+        core
+      )
+    })
   }
 }
 
 /**
  * This is the entrypoint of the script.
  *
  * @param octokit {import('@octokit/rest').Octokit} the Octokit instance to use
+ * @param core {import('@actions/core')} GitHub Actions toolkit, for logging
  */
-export const main = async (octokit) => {
+export const main = async (octokit, core) => {
+  core.debug('Starting PR script')
+
   const { eventName, eventAction, prNodeId } = JSON.parse(
     readFileSync('/tmp/event.json', 'utf-8')
   )
+  core.debug(
+    `Event details - Name: ${eventName}, Action: ${eventAction}, PR Node ID: ${prNodeId}`
+  )
 
   const pr = new PullRequest(octokit, prNodeId)
   await pr.init()
 
-  const prBoard = await getBoard(octokit, 'PRs')
-  const backlogBoard = await getBoard(octokit, 'Backlog')
+  const prBoard = await getBoard(octokit, core, 'PRs')
+  const backlogBoard = await getBoard(octokit, core, 'Backlog')
 
-  // Create new, or get the existing, card for the current pull request.
   const prCard = await prBoard.addCard(pr.nodeId)
+  core.debug(`PR card created or fetched: ${prCard.id}`)
 
-  if (eventName === 'pull_request_review') {
-    await syncReviews(pr, prBoard, prCard)
-  } else {
-    switch (eventAction) {
-      case 'opened':
-      case 'reopened': {
-        if (pr.isDraft) {
-          await prBoard.moveCard(prCard.id, prBoard.columns.Draft)
-        } else {
+  await core.group('Processing PR based on event action', async () => {
+    if (eventName === 'pull_request_review') {
+      await syncReviews(pr, prBoard, prCard)
+    } else {
+      switch (eventAction) {
+        case 'opened':
+        case 'reopened': {
+          core.debug('PR opened or reopened')
+          if (pr.isDraft) {
+            await prBoard.moveCard(prCard.id, prBoard.columns.Draft, core)
+          } else {
+            await syncReviews(pr, prBoard, prCard)
+          }
+          await syncIssues(pr, backlogBoard, 'InProgress')
+          break
+        }
+        case 'edited': {
+          await syncIssues(pr, backlogBoard, 'InProgress')
+          break
+        }
+        case 'converted_to_draft': {
+          await prBoard.moveCard(prCard.id, prBoard.columns.Draft, core)
+          break
+        }
+        case 'ready_for_review': {
+          core.debug('PR ready for review')
           await syncReviews(pr, prBoard, prCard)
+          break
         }
-        await syncIssues(pr, backlogBoard, 'InProgress')
-        break
-      }
-
-      case 'edited': {
-        await syncIssues(pr, backlogBoard, 'InProgress')
-        break
-      }
-
-      case 'converted_to_draft': {
-        await prBoard.moveCard(prCard.id, prBoard.columns.Draft)
-        break
-      }
-
-      case 'ready_for_review': {
-        await syncReviews(pr, prBoard, prCard)
-        break
-      }
-
-      case 'closed': {
-        if (!pr.isMerged) {
-          await syncIssues(pr, backlogBoard, 'Backlog')
+        case 'closed': {
+          core.debug('PR closed')
+          if (!pr.isMerged) {
+            await syncIssues(pr, backlogBoard, 'Backlog')
+          }
+          break
         }
-        break
       }
     }
-  }
+  })
 }