Update

[ghstack-poisoned]

Author: huydhn

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

@@ -41,12 +41,14 @@ separate function.
 
 It is reached through `lambda:InvokeFunction` rather than its public function URL
 (`AuthType: NONE`), so the path from here to classification never crosses a
-public endpoint. `log_classifier` builds on `lambda_http` with only the
-`apigw_http` feature, so `classifier_payload()` reproduces an API Gateway HTTP API
-v2.0 request. 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 from a direct invoke.
+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.
 
 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,56 +135,21 @@ 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.
 
     Asynchronous, and reached through `lambda:InvokeFunction` rather than
     log_classifier's public function URL, so the path from here to classification
-    never crosses a public endpoint.
+    never crosses a public endpoint. A function URL would not do: it only supports
+    the RequestResponse invocation type, so using one means waiting for
+    classification to finish -- which is exactly the mistake that gave
+    github-status-test its multi-hundred-second tails.
     """
     try:
         lambda_client.invoke(
             FunctionName=LOG_CLASSIFIER_FUNCTION,
             InvocationType="Event",
-            Payload=json.dumps(classifier_payload(full_name, job_id)).encode(),
+            Payload=json.dumps({"job_id": job_id, "repo": full_name}).encode(),
         )
         return True
     except Exception as err:

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

@@ -4,7 +4,6 @@
 
 import lambda_function
 from lambda_function import (
-    classifier_payload,
     classify_log,
     download_log,
     installation_token,
@@ -56,23 +55,6 @@ 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:
@@ -83,9 +65,11 @@ 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"])["queryStringParameters"],
-            {"job_id": "123", "repo": "pytorch/pytorch"},
+            json.loads(kwargs["Payload"]),
+            {"job_id": 123, "repo": "pytorch/pytorch"},
         )
 
     def test_a_failed_invoke_is_reported_not_raised(self):