Pass X-GitHub-Delivery Header Value downstream for better correlation

Author: hexa2k9

app/clients/gcloud_client.py

@@ -54,7 +54,14 @@ def _get_template_name(self, template_name):
         except Exception:
             return None
 
-    def create_runner_instance(self, registration_token, repo_url, template_name, instance_label=None):
+    def create_runner_instance(
+        self,
+        registration_token,
+        repo_url,
+        template_name,
+        instance_label=None,
+        delivery_id=None,
+    ):
         """
         Create a new GCE instance for a GitHub Actions runner.
 
@@ -63,16 +70,26 @@ def create_runner_instance(self, registration_token, repo_url, template_name, in
             repo_url (str): The URL of the repository or organization.
             template_name (str): The name of the instance template to use.
             instance_label (str): Label to add to the Instance for Cost Tracking.
+            delivery_id (str): The GitHub webhook delivery ID for log correlation.
 
         Returns:
             str: The name of the created instance.
         """
         instance_template_resource = self._get_template_name(template_name)
         if instance_template_resource:
-            logger.info(f"Found matching instance template: {instance_template_resource.name}")
+            logger.info(
+                "Found matching instance template: %s, delivery_id: %s",
+                instance_template_resource.name,
+                delivery_id,
+            )
         else:
-            logger.warning(f"No matching instance template found for label '{template_name}' in region {self.region}. "
-                           "Skipping instance creation.")
+            logger.warning(
+                "No matching instance template found for label '%s' in region %s. "
+                "Skipping instance creation. delivery_id: %s",
+                template_name,
+                self.region,
+                delivery_id,
+            )
             return None
 
         instance_uuid = uuid.uuid4().hex[:16]
@@ -81,7 +98,12 @@ def create_runner_instance(self, registration_token, repo_url, template_name, in
         else:
             instance_name = f"runner-{instance_uuid}"
 
-        logger.info(f"Creating GCE instance {instance_name} with template {instance_template_resource.self_link}")
+        logger.info(
+            "Creating GCE instance %s with template %s, delivery_id: %s",
+            instance_name,
+            instance_template_resource.self_link,
+            delivery_id,
+        )
 
         # Set instance name
         instance_resource = compute_v1.Instance()  # google.cloud.compute_v1.types.Instance
@@ -122,30 +144,46 @@ def create_runner_instance(self, registration_token, repo_url, template_name, in
 
         try:
             # https://docs.cloud.google.com/compute/docs/reference/rest/v1/instances/insert
-            operation = self.instance_client.insert(
-                request=request
+            operation = self.instance_client.insert(request=request)
+            logger.info(
+                "Instance creation operation started: %s, delivery_id: %s",
+                operation.name,
+                delivery_id,
             )
-            logger.info(f"Instance creation operation started: {operation.name}")
             return instance_name
         except Exception as e:
-            logger.error(f"Failed to create instance: {e}")
+            logger.error(
+                "Failed to create instance: %s, delivery_id: %s", e, delivery_id
+            )
             raise
 
-    def delete_runner_instance(self, instance_name):
+    def delete_runner_instance(self, instance_name, delivery_id=None):
         """
         Delete a GCE instance.
 
         Args:
             instance_name (str): The name of the instance to delete.
+            delivery_id (str): The GitHub webhook delivery ID for log correlation.
         """
-        logger.info(f"Deleting GCE instance {instance_name}")
+        logger.info(
+            "Deleting GCE instance %s, delivery_id: %s", instance_name, delivery_id
+        )
         try:
             operation = self.instance_client.delete(
                 project=self.project_id,
                 zone=self.zone,
                 instance=instance_name
             )
-            logger.info(f"Instance deletion operation started: {operation.name}")
+            logger.info(
+                "Instance deletion operation started: %s, delivery_id: %s",
+                operation.name,
+                delivery_id,
+            )
         except Exception as e:
-            logger.error(f"Failed to delete instance {instance_name}: {e}")
+            logger.error(
+                "Failed to delete instance %s: %s, delivery_id: %s",
+                instance_name,
+                e,
+                delivery_id,
+            )
             raise

app/clients/github_client.py

@@ -79,7 +79,7 @@ def get_installation_access_token(self):
         # The installation access token will expire after 1 hour.
         return response.json()['token']
 
-    def get_registration_token(self, org_name=None, repo_name=None):
+    def get_registration_token(self, org_name=None, repo_name=None, delivery_id=None):
         """Gets a runner registration token."""
         # https://docs.github.com/en/rest/actions/self-hosted-runners
         token = self.get_installation_access_token()
@@ -90,12 +90,20 @@ def get_registration_token(self, org_name=None, repo_name=None):
         }
         if org_name:
             # GitHub Docs: https://t.ly/dAyGK
-            url = f'https://api.github.com/orgs/{org_name}/actions/runners/registration-token'
-            logger.info(f"Create registration token for organization: {org_name}")
+            url = f"https://api.github.com/orgs/{org_name}/actions/runners/registration-token"
+            logger.info(
+                "Create registration token for organization: %s, delivery_id: %s",
+                org_name,
+                delivery_id,
+            )
         elif repo_name:
             # GitHub Docs: https://t.ly/n0w2a
-            url = f'https://api.github.com/repos/{repo_name}/actions/runners/registration-token'
-            logger.info(f"Create registration token for repository: {repo_name}")
+            url = f"https://api.github.com/repos/{repo_name}/actions/runners/registration-token"
+            logger.info(
+                "Create registration token for repository: %s, delivery_id: %s",
+                repo_name,
+                delivery_id,
+            )
         else:
             raise ValueError("Either org_name or repo_name must be provided")
 

app/routes/webhook.py

@@ -73,7 +73,7 @@ def handle_workflow_job_event(payload, delivery_id=None):
     """Handle workflow_job event."""
     try:
         webhook_service = WebhookService()
-        result = webhook_service.handle_workflow_job(payload)
+        result = webhook_service.handle_workflow_job(payload, delivery_id=delivery_id)
         logger.info(
             "Webhook processed successfully, action: %s, runner_name: %s, "
             "delivery_id: %s",

app/services/webhook_service.py

@@ -40,7 +40,7 @@ def _validate_payload(self, payload):
 
         return True
 
-    def handle_workflow_job(self, payload):
+    def handle_workflow_job(self, payload, delivery_id=None):
         """Process the workflow_job webhook payload from GitHub.
 
         Returns:
@@ -59,7 +59,12 @@ def handle_workflow_job(self, payload):
         org_name = payload.get('organization', {}).get('login')
 
         # Sanitize log output - don't log full payload
-        logger.info("Processing workflow_job action: %s for %s", action, org_name or repo_name)
+        logger.info(
+            "Processing workflow_job action: %s for %s, delivery_id: %s",
+            action,
+            org_name or repo_name,
+            delivery_id,
+        )
 
         # https://docs.github.com/en/webhooks/webhook-events-and-payloads?actionType=queued#workflow_job
         if action == 'queued':
@@ -70,27 +75,46 @@ def handle_workflow_job(self, payload):
                         template_name = label
                         break
             if template_name:
-                logger.info("Found matching label prefix: %s", template_name)
+                logger.info(
+                    "Found matching label prefix: %s, delivery_id: %s",
+                    template_name,
+                    delivery_id,
+                )
                 instance_name = self._handle_queued_job(
-                    template_name, repo_url, repo_owner_url, repo_name, org_name
+                    template_name,
+                    repo_url,
+                    repo_owner_url,
+                    repo_name,
+                    org_name,
+                    delivery_id=delivery_id,
                 )
                 return {'action': 'created', 'runner_name': instance_name}
             else:
                 logger.warning(
-                    "No matching gcp- label prefix found for labels %s. Ignoring job.",
+                    "No matching gcp- label prefix found for labels %s. "
+                    "Ignoring job. delivery_id: %s",
                     labels,
+                    delivery_id,
                 )
                 return {'action': 'ignored', 'runner_name': None}
 
         # https://docs.github.com/en/webhooks/webhook-events-and-payloads?actionType=completed#workflow_job
         elif action == 'completed':
-            runner_name = self._handle_completed_job(workflow_job)
+            runner_name = self._handle_completed_job(
+                workflow_job, delivery_id=delivery_id
+            )
             return {'action': 'deleted', 'runner_name': runner_name}
 
         return {'action': 'ignored', 'runner_name': None}
 
     def _handle_queued_job(
-        self, template_name, repo_url, repo_owner_url, repo_name, org_name
+        self,
+        template_name,
+        repo_url,
+        repo_owner_url,
+        repo_name,
+        org_name,
+        delivery_id=None,
     ):
         """Handle queued workflow job.
 
@@ -101,42 +125,68 @@ def _handle_queued_job(
             # Get registration token
             if org_name:
                 # Create GitHub Actions runner instance for organization
-                token = self.github_client.get_registration_token(org_name=org_name)
+                token = self.github_client.get_registration_token(
+                    org_name=org_name, delivery_id=delivery_id
+                )
                 return self.gcloud_client.create_runner_instance(
-                    token, repo_owner_url, template_name, repo_name
+                    token,
+                    repo_owner_url,
+                    template_name,
+                    repo_name,
+                    delivery_id=delivery_id,
                 )
             elif repo_name:
                 # Create GitHub Actions runner instance for repository
-                token = self.github_client.get_registration_token(repo_name=repo_name)
+                token = self.github_client.get_registration_token(
+                    repo_name=repo_name, delivery_id=delivery_id
+                )
                 return self.gcloud_client.create_runner_instance(
-                    token, repo_url, template_name, repo_name
+                    token, repo_url, template_name, repo_name, delivery_id=delivery_id
                 )
             else:
                 logger.error(
-                    "Neither repository nor organization found in payload. Ignoring job."
+                    "Neither repository nor organization found in payload. "
+                    "Ignoring job. delivery_id: %s",
+                    delivery_id,
                 )
                 return None
 
         except Exception as e:
-            logger.error("Failed to spawn runner: %s", str(e))
+            logger.error(
+                "Failed to spawn runner: %s, delivery_id: %s", str(e), delivery_id
+            )
             raise
 
-    def _handle_completed_job(self, workflow_job):
+    def _handle_completed_job(self, workflow_job, delivery_id=None):
         """Handle completed workflow job.
 
         Returns:
             str or None: The name of the deleted runner instance.
         """
         runner_name = workflow_job.get('runner_name')
-        logger.info("Job completed. Cleaning up runner: %s", runner_name)
+        logger.info(
+            "Job completed. Cleaning up runner: %s, delivery_id: %s",
+            runner_name,
+            delivery_id,
+        )
 
         if not runner_name:
-            logger.warning("Job completed but no runner_name found in payload.")
+            logger.warning(
+                "Job completed but no runner_name found in payload. delivery_id: %s",
+                delivery_id,
+            )
             return None
 
         try:
-            self.gcloud_client.delete_runner_instance(runner_name)
+            self.gcloud_client.delete_runner_instance(
+                runner_name, delivery_id=delivery_id
+            )
             return runner_name
         except Exception as e:
-            logger.error("Failed to delete runner %s: %s", runner_name, str(e))
+            logger.error(
+                "Failed to delete runner %s: %s, delivery_id: %s",
+                runner_name,
+                str(e),
+                delivery_id,
+            )
             return runner_name