add logging to debug failing executions

Author: Fernando Arozarena

src/github.ts

@@ -27,26 +27,34 @@ export class OctokitGitHub {
     });
   }
 
-  workflows = async (owner: string, repo: string) =>
-    this.octokit.paginate(this.octokit.actions.listRepoWorkflows, {
+  workflows = async (owner: string, repo: string) => {
+    debug(`🔍 API Call: GET /repos/${owner}/${repo}/actions/workflows`);
+    const workflows = await this.octokit.paginate(this.octokit.actions.listRepoWorkflows, {
       owner,
       repo,
       per_page: 100,
     });
+    debug(`📋 API Response: Found ${workflows.length} workflows`);
+    debug(`📋 Workflows details: ${JSON.stringify(workflows.map(w => ({ id: w.id, name: w.name, state: w.state })), null, 2)}`);
+    return workflows;
+  };
 
   runs = async (owner: string, repo: string, branch: string | undefined, workflow_id: number) => {
     const options: Endpoints['GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs']['parameters'] =
-      {
-        owner,
-        repo,
-        workflow_id,
-        per_page: 100,
-      };
+    {
+      owner,
+      repo,
+      workflow_id,
+      per_page: 100,
+    };
 
     if (branch) {
       options.branch = branch;
     }
 
+    debug(`🔍 API Call: GET /repos/${owner}/${repo}/actions/workflows/${workflow_id}/runs`);
+    debug(`🔍 Request options: ${JSON.stringify({ ...options, branch: branch || 'all branches' }, null, 2)}`);
+
     const in_progress_options = {
       ...options,
       status: 'in_progress' as const,
@@ -60,6 +68,8 @@ export class OctokitGitHub {
       status: 'waiting' as const,
     };
 
+    debug(`🔍 Making 3 parallel API calls for statuses: in_progress, queued, waiting`);
+
     const in_progress_runs = this.octokit.paginate(
       this.octokit.actions.listWorkflowRuns,
       in_progress_options,
@@ -75,21 +85,42 @@ export class OctokitGitHub {
       waiting_options,
     );
 
-    return Promise.all([in_progress_runs, queued_runs, waiting_runs]).then((values) =>
-      values.flat(),
-    );
+    const [inProgressResults, queuedResults, waitingResults] = await Promise.all([in_progress_runs, queued_runs, waiting_runs]);
+
+    debug(`📋 API Response - in_progress runs: ${inProgressResults.length}`);
+    debug(`📋 API Response - queued runs: ${queuedResults.length}`);
+    debug(`📋 API Response - waiting runs: ${waitingResults.length}`);
+
+    const allRuns = [inProgressResults, queuedResults, waitingResults].flat();
+    debug(`📋 Total runs found: ${allRuns.length}`);
+
+    // Log detailed info about each run
+    allRuns.forEach((run, index) => {
+      debug(`📋 Run ${index + 1}: ID=${run.id}, status="${run.status}", conclusion="${run.conclusion}", created_at="${run.created_at}", branch="${run.head_branch}"`);
+    });
+
+    return allRuns;
   };
 
   jobs = async (owner: string, repo: string, run_id: number) => {
     const options: Endpoints['GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs']['parameters'] =
-      {
-        owner,
-        repo,
-        run_id,
-        per_page: 100,
-      };
-
-    return this.octokit.paginate(this.octokit.actions.listJobsForWorkflowRun, options);
+    {
+      owner,
+      repo,
+      run_id,
+      per_page: 100,
+    };
+
+    debug(`🔍 API Call: GET /repos/${owner}/${repo}/actions/runs/${run_id}/jobs`);
+    const jobs = await this.octokit.paginate(this.octokit.actions.listJobsForWorkflowRun, options);
+    debug(`📋 API Response: Found ${jobs.length} jobs for run ${run_id}`);
+
+    // Log detailed info about each job
+    jobs.forEach((job, index) => {
+      debug(`📋 Job ${index + 1}: ID=${job.id}, name="${job.name}", status="${job.status}", conclusion="${job.conclusion}", started_at="${job.started_at}"`);
+    });
+
+    return jobs;
   };
 
   steps = async (owner: string, repo: string, job_id: number) => {
@@ -98,7 +129,17 @@ export class OctokitGitHub {
       repo,
       job_id,
     };
+
+    debug(`🔍 API Call: GET /repos/${owner}/${repo}/actions/jobs/${job_id}`);
     const { data: job } = await this.octokit.actions.getJobForWorkflowRun(options);
-    return job.steps || [];
+    const steps = job.steps || [];
+    debug(`📋 API Response: Found ${steps.length} steps for job ${job_id}`);
+
+    // Log detailed info about each step
+    steps.forEach((step, index) => {
+      debug(`📋 Step ${index + 1}: name="${step.name}", status="${step.status}", conclusion="${step.conclusion}", started_at="${step.started_at}"`);
+    });
+
+    return steps;
   };
 }

src/wait.ts

@@ -53,6 +53,8 @@ export class Waiter implements Wait {
     );
 
     this.debug(`Found ${runs.length} ${this.workflowId} runs`);
+    this.debug(`🔍 Current run ID: ${this.input.runId}`);
+    this.debug(`🔍 Branch filter: ${this.input.sameBranchOnly ? this.input.branch : 'all branches'}`);
 
     const queueName = this.input.queueName;
     let filteredRuns = runs;
@@ -65,6 +67,8 @@ export class Waiter implements Wait {
 
         if (matchesQueue) {
           this.debug(`Run ${run.id} matches queue name: ${queueName}`);
+        } else {
+          this.debug(`Run ${run.id} does NOT match queue name: ${queueName} (display_title: "${run.display_title}", name: "${run.name}")`);
         }
 
         return matchesQueue;
@@ -73,20 +77,33 @@ export class Waiter implements Wait {
       this.debug(`After queue filtering: ${filteredRuns.length} runs match queue "${queueName}"`);
     }
 
-    const previousRuns = filteredRuns
-      .filter((run) => run.id < this.input.runId)
+    // Filter runs that started before current run
+    const runsBeforeCurrent = filteredRuns.filter((run) => run.id < this.input.runId);
+    this.debug(`🔍 Runs before current (ID < ${this.input.runId}): ${runsBeforeCurrent.length}`);
+
+    runsBeforeCurrent.forEach((run) => {
+      this.debug(`🔍 Run ${run.id}: status="${run.status}", conclusion="${run.conclusion}", created_at="${run.created_at}"`);
+    });
+
+    const previousRuns = runsBeforeCurrent
       .filter((run) => {
         const isSuccessful: boolean = run.conclusion === 'success';
 
         if (isSuccessful) {
           this.debug(
-            `Skipping run ${run.id}, status: ${run.status}, conclusion: ${run.conclusion}`,
+            `✅ Skipping successful run ${run.id}, status: ${run.status}, conclusion: ${run.conclusion}`,
+          );
+        } else {
+          this.debug(
+            `⏳ Will wait for run ${run.id}, status: ${run.status}, conclusion: ${run.conclusion}`,
           );
         }
 
         return !isSuccessful;
       })
       .sort((a, b) => b.id - a.id);
+
+    this.debug(`🔍 Final previousRuns to wait for: ${previousRuns.length}`);
     if (!previousRuns || !previousRuns.length) {
       setOutput('force_continued', '');
       if (