Update

[ghstack-poisoned]

Author: huydhn

aws/lambda/gha-log-uploader/README.md

@@ -45,10 +45,19 @@ public endpoint. A function URL would not work anyway: those only support the
 `RequestResponse` invocation type, so calling one means waiting for
 classification to finish.
 
-The payload is just `{"job_id": ..., "repo": "..."}`. `log_classifier` accepts
-that shape alongside the API Gateway request its function URL callers send — see
-`parse_request` in `../log-classifier/src/main.rs`, whose
-`parses_a_direct_invoke_payload` test pins this contract from the other side.
+`log_classifier` builds on `lambda_http` with only the `apigw_http` feature, so
+`classifier_payload()` reproduces the API Gateway HTTP API v2.0 request it
+expects even on a direct invoke. Verified against the deployed function: a
+payload with no `job_id` returns its 400 "no job id provided" branch, and a
+non-numeric one fails inside its `parse::<usize>()`, which together show both the
+envelope and the query string are read.
+
+That envelope is coupling to another lambda's framework, and it would break if
+`log_classifier`'s handler changed. Teaching it to accept a plain
+`{"job_id", "repo"}` payload is the real fix, and lets its public function URL be
+retired once `backfillJobs.mjs`, `keep-going-call-log-classifier` and
+`github-status-test` move off it too — worth doing on its own, not as a rider on
+this migration.
 
 A failed handoff is logged and reported as `classified: false`, not raised.
 Raising would make Lambda retry the whole function, re-downloading a

aws/lambda/gha-log-uploader/lambda_function.py

@@ -135,6 +135,44 @@ def log_object_path(full_name, job_id):
     return f"log/{full_name}/{job_id}"
 
 
+def classifier_payload(full_name, job_id):
+    """An API Gateway HTTP API v2.0 request, which is what lambda_http parses.
+
+    log_classifier is built on lambda_http with only the `apigw_http` feature, so
+    it expects this envelope even on a direct invoke. Verified against the
+    deployed function: a payload with no `job_id` returns its 400 "no job id
+    provided" branch, and a non-numeric one fails in its `parse::<usize>()`,
+    which together show both the envelope and the query string are read.
+    """
+    return {
+        "version": "2.0",
+        "routeKey": "$default",
+        "rawPath": "/",
+        "rawQueryString": f"job_id={job_id}&repo={full_name}",
+        "headers": {},
+        "queryStringParameters": {"job_id": str(job_id), "repo": full_name},
+        "requestContext": {
+            "accountId": "308535385114",
+            "apiId": "gha-log-uploader",
+            "domainName": "lambda-invoke",
+            "domainPrefix": "lambda-invoke",
+            "http": {
+                "method": "GET",
+                "path": "/",
+                "protocol": "HTTP/1.1",
+                "sourceIp": "127.0.0.1",
+                "userAgent": "gha-log-uploader",
+            },
+            "requestId": f"gha-log-uploader-{job_id}",
+            "routeKey": "$default",
+            "stage": "$default",
+            "time": "01/Jan/1970:00:00:00 +0000",
+            "timeEpoch": 0,
+        },
+        "isBase64Encoded": False,
+    }
+
+
 def classify_log(full_name, job_id):
     """Kick off classification for a log we just stored. Returns True on handoff.
 
@@ -149,7 +187,7 @@ def classify_log(full_name, job_id):
         lambda_client.invoke(
             FunctionName=LOG_CLASSIFIER_FUNCTION,
             InvocationType="Event",
-            Payload=json.dumps({"job_id": job_id, "repo": full_name}).encode(),
+            Payload=json.dumps(classifier_payload(full_name, job_id)).encode(),
         )
         return True
     except Exception as err:

aws/lambda/gha-log-uploader/test_lambda_function.py

@@ -4,6 +4,7 @@
 
 import lambda_function
 from lambda_function import (
+    classifier_payload,
     classify_log,
     download_log,
     installation_token,
@@ -55,6 +56,23 @@ def test_rejects_a_non_object_payload(self):
             parse_event(["pytorch/pytorch", 123])
 
 
+class TestClassifierPayload(unittest.TestCase):
+    def test_is_a_v2_request_the_classifier_can_parse(self):
+        payload = classifier_payload("pytorch/executorch", 999)
+        # log_classifier builds on lambda_http with only the apigw_http feature,
+        # so version 2.0 and requestContext.http are what make it deserialize.
+        self.assertEqual(payload["version"], "2.0")
+        self.assertIn("http", payload["requestContext"])
+        self.assertEqual(
+            payload["queryStringParameters"],
+            {"job_id": "999", "repo": "pytorch/executorch"},
+        )
+        self.assertEqual(payload["rawQueryString"], "job_id=999&repo=pytorch/executorch")
+
+    def test_is_json_serializable(self):
+        json.dumps(classifier_payload("pytorch/pytorch", 1))
+
+
 class TestClassifyLog(unittest.TestCase):
     def test_invokes_the_classifier_asynchronously(self):
         with patch.object(lambda_function, "lambda_client") as client:
@@ -65,11 +83,9 @@ def test_invokes_the_classifier_asynchronously(self):
         # Event, not RequestResponse: waiting on classification is exactly the
         # mistake that gave github-status-test its multi-hundred-second tails.
         self.assertEqual(kwargs["InvocationType"], "Event")
-        # The plain shape log_classifier's parse_request accepts. Its
-        # parses_a_direct_invoke_payload test pins the other side of this.
         self.assertEqual(
-            json.loads(kwargs["Payload"]),
-            {"job_id": 123, "repo": "pytorch/pytorch"},
+            json.loads(kwargs["Payload"])["queryStringParameters"],
+            {"job_id": "123", "repo": "pytorch/pytorch"},
         )
 
     def test_a_failed_invoke_is_reported_not_raised(self):