functions-framework 3.6.0__tar.gz → 3.8.0__tar.gz

{functions_framework-3.6.0 → functions_framework-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: functions-framework
-Version: 3.6.0
+Version: 3.8.0
 Summary: An open source FaaS (Function as a service) framework for writing portable Python functions -- brought to you by the Google Cloud Functions team.
 Home-page: https://github.com/googlecloudplatform/functions-framework-python
 Author: Google LLC
@@ -23,6 +23,7 @@ Requires-Dist: click<9.0,>=7.0
 Requires-Dist: watchdog>=1.0.0
 Requires-Dist: gunicorn>=19.2.0; platform_system != "Windows"
 Requires-Dist: cloudevents<2.0.0,>=1.2.0
+Requires-Dist: Werkzeug<4.0.0,>=0.14
 
 # Functions Framework for Python
 

{functions_framework-3.6.0 → functions_framework-3.8.0}/setup.py

@@ -25,7 +25,7 @@ with open(path.join(here, "README.md"), encoding="utf-8") as f:
 
 setup(
     name="functions-framework",
-    version="3.6.0",
+    version="3.8.0",
     description="An open source FaaS (Function as a service) framework for writing portable Python functions -- brought to you by the Google Cloud Functions team.",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -55,6 +55,7 @@ setup(
         "watchdog>=1.0.0",
         "gunicorn>=19.2.0; platform_system!='Windows'",
         "cloudevents>=1.2.0,<2.0.0",
+        "Werkzeug>=0.14,<4.0.0",
     ],
     entry_points={
         "console_scripts": [

{functions_framework-3.6.0 → functions_framework-3.8.0}/src/functions_framework/__init__.py

@@ -17,6 +17,8 @@ import inspect
 import io
 import json
 import logging
+import logging.config
+import os
 import os.path
 import pathlib
 import sys
@@ -32,7 +34,12 @@ import werkzeug
 from cloudevents.http import from_http, is_binary
 from cloudevents.http.event import CloudEvent
 
-from functions_framework import _function_registry, _typed_event, event_conversion
+from functions_framework import (
+    _function_registry,
+    _typed_event,
+    event_conversion,
+    execution_id,
+)
 from functions_framework.background_event import BackgroundEvent
 from functions_framework.exceptions import (
     EventConversionException,
@@ -129,6 +136,7 @@ def setup_logging():
 
 
 def _http_view_func_wrapper(function, request):
+    @execution_id.set_execution_context(request, _enable_execution_id_logging())
     @functools.wraps(function)
     def view_func(path):
         return function(request._get_current_object())
@@ -143,6 +151,7 @@ def _run_cloud_event(function, request):
 
 
 def _typed_event_func_wrapper(function, request, inputType: Type):
+    @execution_id.set_execution_context(request, _enable_execution_id_logging())
     def view_func(path):
         try:
             data = request.get_json()
@@ -163,6 +172,7 @@ def _typed_event_func_wrapper(function, request, inputType: Type):
 
 
 def _cloud_event_view_func_wrapper(function, request):
+    @execution_id.set_execution_context(request, _enable_execution_id_logging())
     def view_func(path):
         ce_exception = None
         event = None
@@ -198,6 +208,7 @@ def _cloud_event_view_func_wrapper(function, request):
 
 
 def _event_view_func_wrapper(function, request):
+    @execution_id.set_execution_context(request, _enable_execution_id_logging())
     def view_func(path):
         if event_conversion.is_convertable_cloud_event(request):
             # Convert this CloudEvent to the equivalent background event data and context.
@@ -332,6 +343,9 @@ def create_app(target=None, source=None, signature_type=None):
 
     source_module, spec = _function_registry.load_function_module(source)
 
+    if _enable_execution_id_logging():
+        _configure_app_execution_id_logging()
+
     # Create the application
     _app = flask.Flask(target, template_folder=template_folder)
     _app.register_error_handler(500, crash_handler)
@@ -355,6 +369,7 @@ def create_app(target=None, source=None, signature_type=None):
         sys.stderr = _LoggingHandler("ERROR", sys.stderr)
         setup_logging()
 
+    _app.wsgi_app = execution_id.WsgiMiddleware(_app.wsgi_app)
     # Execute the module, within the application context
     with _app.app_context():
         try:
@@ -411,6 +426,29 @@ class LazyWSGIApp:
         return self.app(*args, **kwargs)
 
 
+def _configure_app_execution_id_logging():
+    # Logging needs to be configured before app logger is accessed
+    logging.config.dictConfig(
+        {
+            "version": 1,
+            "handlers": {
+                "wsgi": {
+                    "class": "logging.StreamHandler",
+                    "stream": "ext://functions_framework.execution_id.logging_stream",
+                },
+            },
+            "root": {"level": "WARNING", "handlers": ["wsgi"]},
+        }
+    )
+
+
+def _enable_execution_id_logging():
+    # Based on distutils.util.strtobool
+    truthy_values = ("y", "yes", "t", "true", "on", "1")
+    env_var_value = os.environ.get("LOG_EXECUTION_ID")
+    return env_var_value in truthy_values
+
+
 app = LazyWSGIApp()
 
 

functions_framework-3.8.0/src/functions_framework/_http/gunicorn.py

@@ -0,0 +1,72 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+import gunicorn.app.base
+
+from gunicorn.workers.gthread import ThreadWorker
+
+from ..request_timeout import ThreadingTimeout
+
+# global for use in our custom gthread worker; the gunicorn arbiter spawns these
+# and it's not possible to inject (and self.timeout means something different to
+# async workers!)
+# set/managed in gunicorn application init for test-friendliness
+TIMEOUT_SECONDS = None
+
+
+class GunicornApplication(gunicorn.app.base.BaseApplication):
+    def __init__(self, app, host, port, debug, **options):
+        threads = int(os.environ.get("THREADS", (os.cpu_count() or 1) * 4))
+
+        global TIMEOUT_SECONDS
+        TIMEOUT_SECONDS = int(os.environ.get("CLOUD_RUN_TIMEOUT_SECONDS", 0))
+
+        self.options = {
+            "bind": "%s:%s" % (host, port),
+            "workers": int(os.environ.get("WORKERS", 1)),
+            "threads": threads,
+            "loglevel": os.environ.get("GUNICORN_LOG_LEVEL", "error"),
+            "limit_request_line": 0,
+        }
+
+        if (
+            TIMEOUT_SECONDS > 0
+            and threads > 1
+            and (os.environ.get("THREADED_TIMEOUT_ENABLED", "False").lower() == "true")
+        ):  # pragma: no cover
+            self.options["worker_class"] = (
+                "functions_framework._http.gunicorn.GThreadWorkerWithTimeoutSupport"
+            )
+        else:
+            self.options["timeout"] = TIMEOUT_SECONDS
+
+        self.options.update(options)
+        self.app = app
+
+        super().__init__()
+
+    def load_config(self):
+        for key, value in self.options.items():
+            self.cfg.set(key, value)
+
+    def load(self):
+        return self.app
+
+
+class GThreadWorkerWithTimeoutSupport(ThreadWorker):  # pragma: no cover
+    def handle_request(self, req, conn):
+        with ThreadingTimeout(TIMEOUT_SECONDS):
+            super(GThreadWorkerWithTimeoutSupport, self).handle_request(req, conn)

{functions_framework-3.6.0 → functions_framework-3.8.0}/src/functions_framework/exceptions.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Google LLC
+# Copyright 2024 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -35,3 +35,7 @@ class MissingTargetException(FunctionsFrameworkException):
 
 class EventConversionException(FunctionsFrameworkException):
     pass
+
+
+class RequestTimeoutException(FunctionsFrameworkException):
+    pass

functions_framework-3.8.0/src/functions_framework/execution_id.py

@@ -0,0 +1,156 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import contextlib
+import functools
+import io
+import json
+import logging
+import random
+import re
+import string
+import sys
+
+import flask
+
+from werkzeug.local import LocalProxy
+
+_EXECUTION_ID_LENGTH = 12
+_EXECUTION_ID_CHARSET = string.digits + string.ascii_letters
+_LOGGING_API_LABELS_FIELD = "logging.googleapis.com/labels"
+_LOGGING_API_SPAN_ID_FIELD = "logging.googleapis.com/spanId"
+_TRACE_CONTEXT_REGEX_PATTERN = re.compile(
+    r"^(?P<trace_id>[\w\d]+)/(?P<span_id>\d+);o=(?P<options>[01])$"
+)
+EXECUTION_ID_REQUEST_HEADER = "Function-Execution-Id"
+TRACE_CONTEXT_REQUEST_HEADER = "X-Cloud-Trace-Context"
+
+logger = logging.getLogger(__name__)
+
+
+class ExecutionContext:
+    def __init__(self, execution_id=None, span_id=None):
+        self.execution_id = execution_id
+        self.span_id = span_id
+
+
+def _get_current_context():
+    return (
+        flask.g.execution_id_context
+        if flask.has_request_context() and "execution_id_context" in flask.g
+        else None
+    )
+
+
+def _set_current_context(context):
+    if flask.has_request_context():
+        flask.g.execution_id_context = context
+
+
+def _generate_execution_id():
+    return "".join(
+        _EXECUTION_ID_CHARSET[random.randrange(len(_EXECUTION_ID_CHARSET))]
+        for _ in range(_EXECUTION_ID_LENGTH)
+    )
+
+
+# Middleware to add execution id to request header if one does not already exist
+class WsgiMiddleware:
+    def __init__(self, wsgi_app):
+        self.wsgi_app = wsgi_app
+
+    def __call__(self, environ, start_response):
+        execution_id = (
+            environ.get("HTTP_FUNCTION_EXECUTION_ID") or _generate_execution_id()
+        )
+        environ["HTTP_FUNCTION_EXECUTION_ID"] = execution_id
+        return self.wsgi_app(environ, start_response)
+
+
+# Sets execution id and span id for the request
+def set_execution_context(request, enable_id_logging=False):
+    if enable_id_logging:
+        stdout_redirect = contextlib.redirect_stdout(
+            LoggingHandlerAddExecutionId(sys.stdout)
+        )
+        stderr_redirect = contextlib.redirect_stderr(
+            LoggingHandlerAddExecutionId(sys.stderr)
+        )
+    else:
+        stdout_redirect = contextlib.nullcontext()
+        stderr_redirect = contextlib.nullcontext()
+
+    def decorator(view_function):
+        @functools.wraps(view_function)
+        def wrapper(*args, **kwargs):
+            trace_context = re.match(
+                _TRACE_CONTEXT_REGEX_PATTERN,
+                request.headers.get(TRACE_CONTEXT_REQUEST_HEADER, ""),
+            )
+            execution_id = request.headers.get(EXECUTION_ID_REQUEST_HEADER)
+            span_id = trace_context.group("span_id") if trace_context else None
+            _set_current_context(ExecutionContext(execution_id, span_id))
+
+            with stderr_redirect, stdout_redirect:
+                return view_function(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+@LocalProxy
+def logging_stream():
+    return LoggingHandlerAddExecutionId(stream=flask.logging.wsgi_errors_stream)
+
+
+class LoggingHandlerAddExecutionId(io.TextIOWrapper):
+    def __new__(cls, stream=sys.stdout):
+        if isinstance(stream, LoggingHandlerAddExecutionId):
+            return stream
+        else:
+            return super(LoggingHandlerAddExecutionId, cls).__new__(cls)
+
+    def __init__(self, stream=sys.stdout):
+        io.TextIOWrapper.__init__(self, io.StringIO())
+        self.stream = stream
+
+    def write(self, contents):
+        if contents == "\n":
+            return
+        current_context = _get_current_context()
+        if current_context is None:
+            self.stream.write(contents + "\n")
+            self.stream.flush()
+            return
+        try:
+            execution_id = current_context.execution_id
+            span_id = current_context.span_id
+            payload = json.loads(contents)
+            if not isinstance(payload, dict):
+                payload = {"message": contents}
+        except json.JSONDecodeError:
+            if len(contents) > 0 and contents[-1] == "\n":
+                contents = contents[:-1]
+            payload = {"message": contents}
+        if execution_id:
+            payload[_LOGGING_API_LABELS_FIELD] = payload.get(
+                _LOGGING_API_LABELS_FIELD, {}
+            )
+            payload[_LOGGING_API_LABELS_FIELD]["execution_id"] = execution_id
+        if span_id:
+            payload[_LOGGING_API_SPAN_ID_FIELD] = span_id
+        self.stream.write(json.dumps(payload))
+        self.stream.write("\n")
+        self.stream.flush()

functions_framework-3.8.0/src/functions_framework/request_timeout.py

@@ -0,0 +1,42 @@
+import ctypes
+import logging
+import threading
+
+from .exceptions import RequestTimeoutException
+
+logger = logging.getLogger(__name__)
+
+
+class ThreadingTimeout(object):  # pragma: no cover
+    def __init__(self, seconds):
+        self.seconds = seconds
+        self.target_tid = threading.current_thread().ident
+        self.timer = None
+
+    def __enter__(self):
+        self.timer = threading.Timer(self.seconds, self._raise_exc)
+        self.timer.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.timer.cancel()
+        if exc_type is RequestTimeoutException:
+            logger.warning(
+                "Request handling exceeded {0} seconds timeout; terminating request handling...".format(
+                    self.seconds
+                ),
+                exc_info=(exc_type, exc_val, exc_tb),
+            )
+        return False
+
+    def _raise_exc(self):
+        ret = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+            ctypes.c_long(self.target_tid), ctypes.py_object(RequestTimeoutException)
+        )
+        if ret == 0:
+            raise ValueError("Invalid thread ID {}".format(self.target_tid))
+        elif ret > 1:
+            ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                ctypes.c_long(self.target_tid), None
+            )
+            raise SystemError("PyThreadState_SetAsyncExc failed")

{functions_framework-3.6.0 → functions_framework-3.8.0}/src/functions_framework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: functions-framework
-Version: 3.6.0
+Version: 3.8.0
 Summary: An open source FaaS (Function as a service) framework for writing portable Python functions -- brought to you by the Google Cloud Functions team.
 Home-page: https://github.com/googlecloudplatform/functions-framework-python
 Author: Google LLC
@@ -23,6 +23,7 @@ Requires-Dist: click<9.0,>=7.0
 Requires-Dist: watchdog>=1.0.0
 Requires-Dist: gunicorn>=19.2.0; platform_system != "Windows"
 Requires-Dist: cloudevents<2.0.0,>=1.2.0
+Requires-Dist: Werkzeug<4.0.0,>=0.14
 
 # Functions Framework for Python
 

{functions_framework-3.6.0 → functions_framework-3.8.0}/src/functions_framework.egg-info/SOURCES.txt

@@ -10,7 +10,9 @@ src/functions_framework/_typed_event.py
 src/functions_framework/background_event.py
 src/functions_framework/event_conversion.py
 src/functions_framework/exceptions.py
+src/functions_framework/execution_id.py
 src/functions_framework/py.typed
+src/functions_framework/request_timeout.py
 src/functions_framework.egg-info/PKG-INFO
 src/functions_framework.egg-info/SOURCES.txt
 src/functions_framework.egg-info/dependency_links.txt
@@ -33,11 +35,13 @@ tests/test_cli.py
 tests/test_cloud_event_functions.py
 tests/test_convert.py
 tests/test_decorator_functions.py
+tests/test_execution_id.py
 tests/test_function_registry.py
 tests/test_functions.py
 tests/test_http.py
 tests/test_main.py
 tests/test_samples.py
+tests/test_timeouts.py
 tests/test_typed_event_functions.py
 tests/test_typing.py
 tests/test_view_functions.py

{functions_framework-3.6.0 → functions_framework-3.8.0}/src/functions_framework.egg-info/requires.txt

@@ -2,6 +2,7 @@ flask<4.0,>=1.0
 click<9.0,>=7.0
 watchdog>=1.0.0
 cloudevents<2.0.0,>=1.2.0
+Werkzeug<4.0.0,>=0.14
 
 [:platform_system != "Windows"]
 gunicorn>=19.2.0

functions_framework-3.8.0/tests/test_execution_id.py

@@ -0,0 +1,382 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import asyncio
+import json
+import pathlib
+import re
+import sys
+
+from functools import partial
+from unittest.mock import Mock
+
+import pretend
+import pytest
+
+from functions_framework import create_app, execution_id
+
+TEST_FUNCTIONS_DIR = pathlib.Path(__file__).resolve().parent / "test_functions"
+TEST_EXECUTION_ID = "test_execution_id"
+TEST_SPAN_ID = "123456"
+
+
+def test_user_function_can_retrieve_execution_id_from_header():
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "function"
+    client = create_app(target, source).test_client()
+    resp = client.post(
+        "/",
+        headers={
+            "Function-Execution-Id": TEST_EXECUTION_ID,
+            "Content-Type": "application/json",
+        },
+    )
+
+    assert resp.get_json()["execution_id"] == TEST_EXECUTION_ID
+
+
+def test_uncaught_exception_in_user_function_sets_execution_id(capsys, monkeypatch):
+    monkeypatch.setenv("LOG_EXECUTION_ID", "true")
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "error"
+    app = create_app(target, source)
+    client = app.test_client()
+    resp = client.post(
+        "/",
+        headers={
+            "Function-Execution-Id": TEST_EXECUTION_ID,
+            "Content-Type": "application/json",
+        },
+    )
+    assert resp.status_code == 500
+    record = capsys.readouterr()
+    assert f'"execution_id": "{TEST_EXECUTION_ID}"' in record.err
+
+
+def test_print_from_user_function_sets_execution_id(capsys, monkeypatch):
+    monkeypatch.setenv("LOG_EXECUTION_ID", "true")
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "print_message"
+    app = create_app(target, source)
+    client = app.test_client()
+    client.post(
+        "/",
+        headers={
+            "Function-Execution-Id": TEST_EXECUTION_ID,
+            "Content-Type": "application/json",
+        },
+        json={"message": "some-message"},
+    )
+    record = capsys.readouterr()
+    assert f'"execution_id": "{TEST_EXECUTION_ID}"' in record.out
+    assert '"message": "some-message"' in record.out
+
+
+def test_log_from_user_function_sets_execution_id(capsys, monkeypatch):
+    monkeypatch.setenv("LOG_EXECUTION_ID", "true")
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "log_message"
+    app = create_app(target, source)
+    client = app.test_client()
+    client.post(
+        "/",
+        headers={
+            "Function-Execution-Id": TEST_EXECUTION_ID,
+            "Content-Type": "application/json",
+        },
+        json={"message": json.dumps({"custom-field": "some-message"})},
+    )
+    record = capsys.readouterr()
+    assert f'"execution_id": "{TEST_EXECUTION_ID}"' in record.err
+    assert '"custom-field": "some-message"' in record.err
+
+
+def test_user_function_can_retrieve_generated_execution_id(monkeypatch):
+    monkeypatch.setattr(
+        execution_id, "_generate_execution_id", lambda: TEST_EXECUTION_ID
+    )
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "function"
+    client = create_app(target, source).test_client()
+    resp = client.post(
+        "/",
+        headers={
+            "Content-Type": "application/json",
+        },
+    )
+
+    assert resp.get_json()["execution_id"] == TEST_EXECUTION_ID
+
+
+def test_does_not_set_execution_id_when_not_enabled(capsys):
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "print_message"
+    app = create_app(target, source)
+    client = app.test_client()
+    client.post(
+        "/",
+        headers={
+            "Function-Execution-Id": TEST_EXECUTION_ID,
+            "Content-Type": "application/json",
+        },
+        json={"message": "some-message"},
+    )
+    record = capsys.readouterr()
+    assert f'"execution_id": "{TEST_EXECUTION_ID}"' not in record.out
+    assert "some-message" in record.out
+
+
+def test_does_not_set_execution_id_when_env_var_is_false(capsys, monkeypatch):
+    monkeypatch.setenv("LOG_EXECUTION_ID", "false")
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "print_message"
+    app = create_app(target, source)
+    client = app.test_client()
+    client.post(
+        "/",
+        headers={
+            "Function-Execution-Id": TEST_EXECUTION_ID,
+            "Content-Type": "application/json",
+        },
+        json={"message": "some-message"},
+    )
+    record = capsys.readouterr()
+    assert f'"execution_id": "{TEST_EXECUTION_ID}"' not in record.out
+    assert "some-message" in record.out
+
+
+def test_does_not_set_execution_id_when_env_var_is_not_bool_like(capsys, monkeypatch):
+    monkeypatch.setenv("LOG_EXECUTION_ID", "maybe")
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "print_message"
+    app = create_app(target, source)
+    client = app.test_client()
+    client.post(
+        "/",
+        headers={
+            "Function-Execution-Id": TEST_EXECUTION_ID,
+            "Content-Type": "application/json",
+        },
+        json={"message": "some-message"},
+    )
+    record = capsys.readouterr()
+    assert f'"execution_id": "{TEST_EXECUTION_ID}"' not in record.out
+    assert "some-message" in record.out
+
+
+def test_generate_execution_id():
+    expected_matching_regex = "^[0-9a-zA-Z]{12}$"
+    actual_execution_id = execution_id._generate_execution_id()
+
+    match = re.match(expected_matching_regex, actual_execution_id).group(0)
+    assert match == actual_execution_id
+
+
+@pytest.mark.parametrize(
+    "headers,expected_execution_id,expected_span_id",
+    [
+        (
+            {
+                "X-Cloud-Trace-Context": f"TRACE_ID/{TEST_SPAN_ID};o=1",
+                "Function-Execution-Id": TEST_EXECUTION_ID,
+            },
+            TEST_EXECUTION_ID,
+            TEST_SPAN_ID,
+        ),
+        (
+            {
+                "X-Cloud-Trace-Context": f"TRACE_ID/{TEST_SPAN_ID};o=1",
+                "Function-Execution-Id": TEST_EXECUTION_ID,
+            },
+            TEST_EXECUTION_ID,
+            TEST_SPAN_ID,
+        ),
+        ({}, None, None),
+        (
+            {
+                "X-Cloud-Trace-Context": "malformed trace context string",
+                "Function-Execution-Id": TEST_EXECUTION_ID,
+            },
+            TEST_EXECUTION_ID,
+            None,
+        ),
+    ],
+)
+def test_set_execution_context(
+    headers, expected_execution_id, expected_span_id, monkeypatch
+):
+    request = pretend.stub(headers=headers)
+
+    def view_func():
+        pass
+
+    monkeypatch.setattr(
+        execution_id, "_generate_execution_id", lambda: TEST_EXECUTION_ID
+    )
+    mock_g = Mock()
+    monkeypatch.setattr(execution_id.flask, "g", mock_g)
+    monkeypatch.setattr(execution_id.flask, "has_request_context", lambda: True)
+    execution_id.set_execution_context(request)(view_func)()
+
+    assert mock_g.execution_id_context.span_id == expected_span_id
+    assert mock_g.execution_id_context.execution_id == expected_execution_id
+
+
+@pytest.mark.parametrize(
+    "log_message,expected_log_json",
+    [
+        ("text message", {"message": "text message"}),
+        (
+            json.dumps({"custom-field1": "value1", "custom-field2": "value2"}),
+            {"custom-field1": "value1", "custom-field2": "value2"},
+        ),
+        ("[]", {"message": "[]"}),
+    ],
+)
+def test_log_handler(monkeypatch, log_message, expected_log_json, capsys):
+    log_handler = execution_id.LoggingHandlerAddExecutionId(stream=sys.stdout)
+    monkeypatch.setattr(
+        execution_id,
+        "_get_current_context",
+        lambda: execution_id.ExecutionContext(
+            span_id=TEST_SPAN_ID, execution_id=TEST_EXECUTION_ID
+        ),
+    )
+    expected_log_json.update(
+        {
+            "logging.googleapis.com/labels": {
+                "execution_id": TEST_EXECUTION_ID,
+            },
+            "logging.googleapis.com/spanId": TEST_SPAN_ID,
+        }
+    )
+
+    log_handler.write(log_message)
+    record = capsys.readouterr()
+    assert json.loads(record.out) == expected_log_json
+    assert json.loads(record.out) == expected_log_json
+
+
+def test_log_handler_without_context_logs_unmodified(monkeypatch, capsys):
+    log_handler = execution_id.LoggingHandlerAddExecutionId(stream=sys.stdout)
+    monkeypatch.setattr(
+        execution_id,
+        "_get_current_context",
+        lambda: None,
+    )
+    expected_message = "log message\n"
+
+    log_handler.write("log message")
+    record = capsys.readouterr()
+    assert record.out == expected_message
+
+
+def test_log_handler_ignores_newlines(monkeypatch, capsys):
+    log_handler = execution_id.LoggingHandlerAddExecutionId(stream=sys.stdout)
+    monkeypatch.setattr(
+        execution_id,
+        "_get_current_context",
+        lambda: execution_id.ExecutionContext(
+            span_id=TEST_SPAN_ID, execution_id=TEST_EXECUTION_ID
+        ),
+    )
+
+    log_handler.write("\n")
+    record = capsys.readouterr()
+    assert record.out == ""
+
+
+def test_log_handler_does_not_nest():
+    log_handler_1 = execution_id.LoggingHandlerAddExecutionId(stream=sys.stdout)
+    log_handler_2 = execution_id.LoggingHandlerAddExecutionId(log_handler_1)
+
+    assert log_handler_1 == log_handler_2
+
+
+def test_log_handler_omits_empty_execution_context(monkeypatch, capsys):
+    log_handler = execution_id.LoggingHandlerAddExecutionId(stream=sys.stdout)
+    monkeypatch.setattr(
+        execution_id,
+        "_get_current_context",
+        lambda: execution_id.ExecutionContext(span_id=None, execution_id=None),
+    )
+    expected_json = {
+        "message": "some message",
+    }
+
+    log_handler.write("some message")
+    record = capsys.readouterr()
+    assert json.loads(record.out) == expected_json
+
+
+@pytest.mark.asyncio
+async def test_maintains_execution_id_for_concurrent_requests(monkeypatch, capsys):
+    monkeypatch.setenv("LOG_EXECUTION_ID", "true")
+    monkeypatch.setattr(
+        execution_id,
+        "_generate_execution_id",
+        Mock(side_effect=("test-execution-id-1", "test-execution-id-2")),
+    )
+
+    expected_logs = (
+        {
+            "message": "message1",
+            "logging.googleapis.com/labels": {"execution_id": "test-execution-id-1"},
+        },
+        {
+            "message": "message2",
+            "logging.googleapis.com/labels": {"execution_id": "test-execution-id-2"},
+        },
+        {
+            "message": "message1",
+            "logging.googleapis.com/labels": {"execution_id": "test-execution-id-1"},
+        },
+        {
+            "message": "message2",
+            "logging.googleapis.com/labels": {"execution_id": "test-execution-id-2"},
+        },
+    )
+
+    source = TEST_FUNCTIONS_DIR / "execution_id" / "main.py"
+    target = "sleep"
+    client = create_app(target, source).test_client()
+    loop = asyncio.get_event_loop()
+    response1 = loop.run_in_executor(
+        None,
+        partial(
+            client.post,
+            "/",
+            headers={
+                "Content-Type": "application/json",
+            },
+            json={"message": "message1"},
+        ),
+    )
+    response2 = loop.run_in_executor(
+        None,
+        partial(
+            client.post,
+            "/",
+            headers={
+                "Content-Type": "application/json",
+            },
+            json={"message": "message2"},
+        ),
+    )
+    await asyncio.wait((response1, response2))
+    record = capsys.readouterr()
+    logs = record.err.strip().split("\n")
+    logs_as_json = tuple(json.loads(log) for log in logs)
+
+    sort_key = lambda d: d["message"]
+    assert sorted(logs_as_json, key=sort_key) == sorted(expected_logs, key=sort_key)

{functions_framework-3.6.0 → functions_framework-3.8.0}/tests/test_http.py

@@ -97,17 +97,17 @@ def test_gunicorn_application(debug):
     assert gunicorn_app.app == app
     assert gunicorn_app.options == {
         "bind": "%s:%s" % (host, port),
-        "workers": os.cpu_count() * 4,
-        "threads": 1,
-        "timeout": 300,
+        "workers": 1,
+        "threads": os.cpu_count() * 4,
+        "timeout": 0,
         "loglevel": "error",
         "limit_request_line": 0,
     }
 
     assert gunicorn_app.cfg.bind == ["1.2.3.4:1234"]
-    assert gunicorn_app.cfg.workers == os.cpu_count() * 4
-    assert gunicorn_app.cfg.threads == 1
-    assert gunicorn_app.cfg.timeout == 300
+    assert gunicorn_app.cfg.workers == 1
+    assert gunicorn_app.cfg.threads == os.cpu_count() * 4
+    assert gunicorn_app.cfg.timeout == 0
     assert gunicorn_app.load() == app
 
 

functions_framework-3.8.0/tests/test_timeouts.py

@@ -0,0 +1,265 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import pathlib
+import socket
+import time
+
+from multiprocessing import Process
+
+import pytest
+import requests
+
+ff_gunicorn = pytest.importorskip("functions_framework._http.gunicorn")
+
+
+from functions_framework import create_app
+
+TEST_FUNCTIONS_DIR = pathlib.Path(__file__).resolve().parent / "test_functions"
+TEST_HOST = "0.0.0.0"
+TEST_PORT = "8080"
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests():
+    # the test samples test also listens on 8080, so let's be good stewards of
+    # the port and make sure it's free
+    _wait_for_no_listen(TEST_HOST, TEST_PORT)
+    yield
+    _wait_for_no_listen(TEST_HOST, TEST_PORT)
+
+
+@pytest.mark.skipif("platform.system() == 'Windows'")
+@pytest.mark.skipif("platform.system() == 'Darwin'")
+@pytest.mark.slow_integration_test
+def test_no_timeout_allows_request_processing_to_finish():
+    source = TEST_FUNCTIONS_DIR / "timeout" / "main.py"
+    target = "function"
+
+    app = create_app(target, source)
+
+    options = {}
+
+    gunicorn_app = ff_gunicorn.GunicornApplication(
+        app, TEST_HOST, TEST_PORT, False, **options
+    )
+
+    gunicorn_p = Process(target=gunicorn_app.run)
+    gunicorn_p.start()
+
+    _wait_for_listen(TEST_HOST, TEST_PORT)
+
+    result = requests.get("http://{}:{}/".format(TEST_HOST, TEST_PORT))
+
+    gunicorn_p.terminate()
+    gunicorn_p.join()
+
+    assert result.status_code == 200
+
+
+@pytest.mark.skipif("platform.system() == 'Windows'")
+@pytest.mark.skipif("platform.system() == 'Darwin'")
+@pytest.mark.slow_integration_test
+def test_timeout_but_not_threaded_timeout_enabled_does_not_kill(monkeypatch):
+    monkeypatch.setenv("CLOUD_RUN_TIMEOUT_SECONDS", "1")
+    monkeypatch.setenv("THREADED_TIMEOUT_ENABLED", "false")
+    source = TEST_FUNCTIONS_DIR / "timeout" / "main.py"
+    target = "function"
+
+    app = create_app(target, source)
+
+    options = {}
+
+    gunicorn_app = ff_gunicorn.GunicornApplication(
+        app, TEST_HOST, TEST_PORT, False, **options
+    )
+
+    gunicorn_p = Process(target=gunicorn_app.run)
+    gunicorn_p.start()
+
+    _wait_for_listen(TEST_HOST, TEST_PORT)
+
+    result = requests.get("http://{}:{}/".format(TEST_HOST, TEST_PORT))
+
+    gunicorn_p.terminate()
+    gunicorn_p.join()
+
+    assert result.status_code == 200
+
+
+@pytest.mark.skipif("platform.system() == 'Windows'")
+@pytest.mark.skipif("platform.system() == 'Darwin'")
+@pytest.mark.slow_integration_test
+def test_timeout_and_threaded_timeout_enabled_kills(monkeypatch):
+    monkeypatch.setenv("CLOUD_RUN_TIMEOUT_SECONDS", "1")
+    monkeypatch.setenv("THREADED_TIMEOUT_ENABLED", "true")
+    source = TEST_FUNCTIONS_DIR / "timeout" / "main.py"
+    target = "function"
+
+    app = create_app(target, source)
+
+    options = {}
+
+    gunicorn_app = ff_gunicorn.GunicornApplication(
+        app, TEST_HOST, TEST_PORT, False, **options
+    )
+
+    gunicorn_p = Process(target=gunicorn_app.run)
+    gunicorn_p.start()
+
+    _wait_for_listen(TEST_HOST, TEST_PORT)
+
+    result = requests.get("http://{}:{}/".format(TEST_HOST, TEST_PORT))
+
+    gunicorn_p.terminate()
+    gunicorn_p.join()
+
+    # Any exception raised in execution is a 500 error. Cloud Functions 1st gen and
+    # 2nd gen/Cloud Run infrastructure doing the timeout will return a 408 (gen 1)
+    # or 504 (gen 2/CR) at the infrastructure layer when request timeouts happen,
+    # and this code will only be available to the user in logs.
+    assert result.status_code == 500
+
+
+@pytest.mark.skipif("platform.system() == 'Windows'")
+@pytest.mark.skipif("platform.system() == 'Darwin'")
+@pytest.mark.slow_integration_test
+def test_timeout_and_threaded_timeout_enabled_but_timeout_not_exceeded_doesnt_kill(
+    monkeypatch,
+):
+    monkeypatch.setenv("CLOUD_RUN_TIMEOUT_SECONDS", "2")
+    monkeypatch.setenv("THREADED_TIMEOUT_ENABLED", "true")
+    source = TEST_FUNCTIONS_DIR / "timeout" / "main.py"
+    target = "function"
+
+    app = create_app(target, source)
+
+    options = {}
+
+    gunicorn_app = ff_gunicorn.GunicornApplication(
+        app, TEST_HOST, TEST_PORT, False, **options
+    )
+
+    gunicorn_p = Process(target=gunicorn_app.run)
+    gunicorn_p.start()
+
+    _wait_for_listen(TEST_HOST, TEST_PORT)
+
+    result = requests.get("http://{}:{}/".format(TEST_HOST, TEST_PORT))
+
+    gunicorn_p.terminate()
+    gunicorn_p.join()
+
+    assert result.status_code == 200
+
+
+@pytest.mark.skipif("platform.system() == 'Windows'")
+@pytest.mark.skipif("platform.system() == 'Darwin'")
+@pytest.mark.slow_integration_test
+def test_timeout_sync_worker_kills_on_timeout(
+    monkeypatch,
+):
+    monkeypatch.setenv("CLOUD_RUN_TIMEOUT_SECONDS", "1")
+    monkeypatch.setenv("WORKERS", 2)
+    monkeypatch.setenv("THREADS", 1)
+    source = TEST_FUNCTIONS_DIR / "timeout" / "main.py"
+    target = "function"
+
+    app = create_app(target, source)
+
+    options = {}
+
+    gunicorn_app = ff_gunicorn.GunicornApplication(
+        app, TEST_HOST, TEST_PORT, False, **options
+    )
+
+    gunicorn_p = Process(target=gunicorn_app.run)
+    gunicorn_p.start()
+
+    _wait_for_listen(TEST_HOST, TEST_PORT)
+
+    result = requests.get("http://{}:{}/".format(TEST_HOST, TEST_PORT))
+
+    gunicorn_p.terminate()
+    gunicorn_p.join()
+
+    assert result.status_code == 500
+
+
+@pytest.mark.skipif("platform.system() == 'Windows'")
+@pytest.mark.skipif("platform.system() == 'Darwin'")
+@pytest.mark.slow_integration_test
+def test_timeout_sync_worker_does_not_kill_if_less_than_timeout(
+    monkeypatch,
+):
+    monkeypatch.setenv("CLOUD_RUN_TIMEOUT_SECONDS", "2")
+    monkeypatch.setenv("WORKERS", 2)
+    monkeypatch.setenv("THREADS", 1)
+    source = TEST_FUNCTIONS_DIR / "timeout" / "main.py"
+    target = "function"
+
+    app = create_app(target, source)
+
+    options = {}
+
+    gunicorn_app = ff_gunicorn.GunicornApplication(
+        app, TEST_HOST, TEST_PORT, False, **options
+    )
+
+    gunicorn_p = Process(target=gunicorn_app.run)
+    gunicorn_p.start()
+
+    _wait_for_listen(TEST_HOST, TEST_PORT)
+
+    result = requests.get("http://{}:{}/".format(TEST_HOST, TEST_PORT))
+
+    gunicorn_p.terminate()
+    gunicorn_p.join()
+
+    assert result.status_code == 200
+
+
+@pytest.mark.skip
+def _wait_for_listen(host, port, timeout=10):
+    # Used in tests to make sure that the gunicorn app has booted and is
+    # listening before sending a test request
+    start_time = time.perf_counter()
+    while True:
+        try:
+            with socket.create_connection((host, port), timeout=timeout):
+                break
+        except OSError as ex:
+            time.sleep(0.01)
+            if time.perf_counter() - start_time >= timeout:
+                raise TimeoutError(
+                    "Waited too long for port {} on host {} to start accepting "
+                    "connections.".format(port, host)
+                ) from ex
+
+
+@pytest.mark.skip
+def _wait_for_no_listen(host, port, timeout=10):
+    # Used in tests to make sure that the port is actually free after
+    # the process binding to it should have been killed
+    start_time = time.perf_counter()
+    while True:
+        try:
+            with socket.create_connection((host, port), timeout=timeout):
+                time.sleep(0.01)
+                if time.perf_counter() - start_time >= timeout:
+                    raise TimeoutError(
+                        "Waited too long for port {} on host {} to stop accepting "
+                        "connections.".format(port, host)
+                    )
+        except OSError as ex:
+            break

{functions_framework-3.6.0 → functions_framework-3.8.0}/tests/test_view_functions.py

@@ -25,7 +25,7 @@ import functions_framework
 def test_http_view_func_wrapper():
     function = pretend.call_recorder(lambda request: "Hello")
     request_object = pretend.stub()
-    local_proxy = pretend.stub(_get_current_object=lambda: request_object)
+    local_proxy = pretend.stub(_get_current_object=lambda: request_object, headers={})
 
     view_func = functions_framework._http_view_func_wrapper(function, local_proxy)
     view_func("/some/path")

functions_framework-3.6.0/src/functions_framework/_http/gunicorn.py

@@ -1,40 +0,0 @@
-# Copyright 2020 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-
-import gunicorn.app.base
-
-
-class GunicornApplication(gunicorn.app.base.BaseApplication):
-    def __init__(self, app, host, port, debug, **options):
-        self.options = {
-            "bind": "%s:%s" % (host, port),
-            "workers": os.environ.get("WORKERS", (os.cpu_count() or 1) * 4),
-            "threads": os.environ.get("THREADS", 1),
-            "timeout": os.environ.get("CLOUD_RUN_TIMEOUT_SECONDS", 300),
-            "loglevel": "error",
-            "limit_request_line": 0,
-        }
-        self.options.update(options)
-        self.app = app
-
-        super().__init__()
-
-    def load_config(self):
-        for key, value in self.options.items():
-            self.cfg.set(key, value)
-
-    def load(self):
-        return self.app