docs(uwsgi): update docs on --lazy-apps for uwsgi and tests (#13550)

**tl;dr**
1. Use `uwsgi>=2.0.30` which has
unbit/uwsgi#2726
2. When using `uwsgi<2.0.30` with `--lazy-apps`, also set
`--skip-atexit`, if you see crashes when workers exit.

-----------------------------------------------------

The following explanation happens on `uwsgi<2.0.30`

When `uwsgi` is configured with `--lazy-apps`, master doesn't load the
application, and simply `fork()` to create workers. Then, the workers
load the application. This is different from when it's not set. Without
`--lazy-apps`, master process first load the application then `fork()`.

dd-trace-py profiler uses Python stdlib `atexit` module to export the
profile when the process exits. The code run to export references global
static `std::string` variables. However, when `--lazy-apps` option is
set, they are destructed before when the profiler needs them to export
the profile, and this leads to an undefined behavior.

When `--lazy-apps` is not set the following sequence of events happens
1. uwsgi master process, initialize Python plugin, loads the
application.
3. The application calls `import ddtrace.profiling.auto` and this leads
all native extensions imported to the Python app. During the process,
the constructors for global static variables are called and their
destructors would be registered to be called by `atexit()` when the
program exits.
4. The application also registers `Profiler.stop()` function to `uwsgi`
python module's `atexit` attribute.
5. Then `uwsgi` calls `atexit(uwsgi_plugins_atexit)` to register each
plugins atexit callbacks, for Python `uwsgi_python_atexit()` function.
And the function will call `Py_Finalize()`
6. Master `fork()`s workers
7. When SIGTERM is received at the master, it sends SIGINT to its
workers
8. In each worker, `uwsgi_python_atexit()` is called, invoking
`Profiler.stop()` and `Py_Finalize()` is called, then destructors for
global static variables are called.

When `--lazy-apps` is set
1. uwsgi matser process still intializes Python interpreter, but skips
loading the application
3. Then `uwsgi` calls `atexit(uwsgi_plugins_atexit)` to register each
plugins atexit callbacks, for Python `uwsgi_python_atexit()` function.
And the function will call `Py_Finalize()`
4. Master `fork()`s workers
5. Workers load the application. The application calls `import
ddtrace.profiling.auto` and this leads all native extensions imported to
the Python app. During the process, the constructors for global static
variables are called and their destructors would be registered to be
called by C `atexit()` when the program exits.
6. When `--lazy-apps` is set, ddtrace simply uses Python's `atexit`
module to call `Profiler.stop()` when the program exits.
7. When SIGTERM is received at the master, it sends SIGINT to its
workers
8. In each worker, since global destructors are registered later than
`uwsgi_python_atexit()` , they're called first.
9. Then `Py_Finalize()` is called in part of `uwsgi_python_atexit()`
calling `Profiler.stop()`. Then it will access those destructed global
static strings leading to undefined behavior.

To workaround this I have tried three different approaches. 

1. #11125: Simply pass the needed `std::string` from Python side to
native when exporting pprof file for test
2. #13520: Leak the strings needed for exporting profile to prevent them
from destructed
3. #13535: Bundle all needed strings needed for exporting profile, and
create them whenever we try to upload.

The first approach only addresses issues from tests.

The second approach mimics what's suggested in
pytorch/pytorch#42125, but since there are a
few other global static variables we have throughout the profiler, this
still showed crashes from test.

And we got similar results from the third approach, as we did from the
second.


Another way to completely work around this problem is setting
`--skip-atexit` as suggested in
ansible/ansible-ai-connect-service#248.

When `--skip-atexit` is set, `uwsgi` uses `_exit()` instead of `exit()`,
and the former doesn't call any functions registered with `atexit()` or
`on_exit()`. So, the static variable destructors are never called, and
the app no longer crashes.

The profiler also doesn't flush the profile via `atexit()` when
`--skip-atexit` is set, but I'd argue losing a single profile at the end
is better than crashing the application even if the application is
exiting. So we'd need to require our customers to set `--skip-atexit`
when `--lazy-apps` is set.

## Checklist
- [x] PR author has checked that all the criteria below are met
- The PR description includes an overview of the change
- The PR description articulates the motivation for the change
- The change includes tests OR the PR description describes a testing
strategy
- The PR description notes risks associated with the change, if any
- Newly-added code is easy to change
- The change follows the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/releasenotes.html)
- The change includes or references documentation updates if necessary
- Backport labels are set (if
[applicable](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting))

## Reviewer Checklist
- [x] Reviewer has checked that all the criteria below are met 
- Title is accurate
- All changes are related to the pull request's stated goal
- Avoids breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes
- Testing strategy adequately addresses listed risks
- Newly-added code is easy to change
- Release note makes sense to a user of the library
- If necessary, author has acknowledged and discussed the performance
implications of this PR as reported in the benchmarks PR comment
- Backport labels are set in a manner that is consistent with the
[release branch maintenance
policy](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting)

Author: taegyunkim

docs/advanced_usage.rst

@@ -517,15 +517,21 @@ uWSGI
 
 - Threads must be enabled with the `enable-threads <https://uwsgi-docs.readthedocs.io/en/latest/Options.html#enable-threads>`__ or `threads <https://uwsgi-docs.readthedocs.io/en/latest/Options.html#threads>`__ options.
 - Lazy apps must be enabled with the `lazy-apps <https://uwsgi-docs.readthedocs.io/en/latest/Options.html#lazy-apps>`__ option.
+- For `uWSGI<2.0.30`, skip atexit, `skip-atexit <https://uwsgi-docs.readthedocs.io/en/latest/Options.html#skip-atexit>`__, must be enabled when `lazy-apps <https://uwsgi-docs.readthedocs.io/en/latest/Options.html#lazy-apps>`__ is enabled. This is to avoid crashes from native extensions that could occur when child processes are terminated.
 - For automatic instrumentation (like ``ddtrace-run``) set the `import <https://uwsgi-docs.readthedocs.io/en/latest/Options.html#import>`__ option to ``ddtrace.bootstrap.sitecustomize``.
 - Gevent patching should NOT be enabled via `--gevent-patch <https://uwsgi-docs.readthedocs.io/en/latest/Gevent.html#monkey-patching>`__ option. Enabling gevent patching for the builtin threading library is NOT supported. Instead use ``import gevent; gevent.monkey.patch_all(thread=False)`` in your application.
 
-Example with CLI arguments:
+Example with CLI arguments for uWSGI>=2.0.30:
 
 .. code-block:: bash
 
   uwsgi --enable-threads --lazy-apps --import=ddtrace.bootstrap.sitecustomize --master --processes=5 --http 127.0.0.1:8000 --module wsgi:app
 
+Example with CLI arguments for uWSGI<2.0.30:
+
+.. code-block:: bash
+
+  uwsgi --enable-threads --lazy-apps --skip-atexit --import=ddtrace.bootstrap.sitecustomize --master --processes=5 --http 127.0.0.1:8000 --module wsgi:app
 
 Example with uWSGI ini file:
 
@@ -542,6 +548,7 @@ Example with uWSGI ini file:
   ;; ddtrace required options
   enable-threads = 1
   lazy-apps = 1
+  skip-atexit = 1 ; For uwsgi<2.0.30
   import=ddtrace.bootstrap.sitecustomize
 
 

releasenotes/notes/profiling-uwsgi-skip-atexit-2d931caef96837b1.yaml

@@ -0,0 +1,7 @@
+---
+other:
+  - |
+    docs: Update docs and tests for uwsgi ``--lazy-apps`` config.
+    For ``uWSGI<2.0.30`` when ``--lazy-apps`` is set , we advise our customers
+    to also set ``--skip-atexit`` to avoid crashes that could occur from our
+    native extensions when worker processes are terminated.

tests/profiling_v2/test_uwsgi.py

@@ -0,0 +1,172 @@
+import os
+import re
+import signal
+from subprocess import TimeoutExpired
+import sys
+import time
+
+import pytest
+
+from tests.contrib.uwsgi import run_uwsgi
+from tests.profiling.collector import pprof_utils
+
+
+# uwsgi is not available on Windows
+if sys.platform == "win32":
+    pytestmark = pytest.mark.skip
+
+TESTING_GEVENT = os.getenv("DD_PROFILE_TEST_GEVENT", False)
+THREADS_MSG = (
+    b"ddtrace.internal.uwsgi.uWSGIConfigError: enable-threads option must be set to true, or a positive "
+    b"number of threads must be set"
+)
+
+uwsgi_app = os.path.join(os.path.dirname(__file__), "..", "profiling", "uwsgi-app.py")
+
+
+@pytest.fixture
+def uwsgi(monkeypatch, tmp_path):
+    # Do not ignore profiler so we have samples in the output pprof
+    monkeypatch.setenv("DD_PROFILING_IGNORE_PROFILER", "0")
+    # Do not use pytest tmpdir fixtures which generate directories longer than allowed for a socket file name
+    socket_name = str(tmp_path / "uwsgi.sock")
+    import os
+
+    cmd = [
+        "uwsgi",
+        "--need-app",
+        "--die-on-term",
+        "--socket",
+        socket_name,
+        "--wsgi-file",
+        uwsgi_app,
+    ]
+
+    try:
+        yield run_uwsgi(cmd)
+    finally:
+        os.unlink(socket_name)
+
+
+def test_uwsgi_threads_disabled(uwsgi):
+    proc = uwsgi()
+    stdout, _ = proc.communicate()
+    assert proc.wait() != 0
+    assert THREADS_MSG in stdout
+
+
+def test_uwsgi_threads_number_set(uwsgi):
+    proc = uwsgi("--threads", "1")
+    try:
+        stdout, _ = proc.communicate(timeout=1)
+    except TimeoutExpired:
+        proc.terminate()
+        stdout, _ = proc.communicate()
+    assert THREADS_MSG not in stdout
+
+
+def test_uwsgi_threads_enabled(uwsgi, tmp_path, monkeypatch):
+    filename = str(tmp_path / "uwsgi.pprof")
+    monkeypatch.setenv("DD_PROFILING_OUTPUT_PPROF", filename)
+    proc = uwsgi("--enable-threads")
+    worker_pids = _get_worker_pids(proc.stdout, 1)
+    # Give some time to the process to actually startup
+    time.sleep(3)
+    proc.terminate()
+    assert proc.wait() == 30
+    for pid in worker_pids:
+        profile = pprof_utils.parse_profile("%s.%d" % (filename, pid))
+        samples = pprof_utils.get_samples_with_value_type(profile, "wall-time")
+        assert len(samples) > 0
+
+
+def test_uwsgi_threads_processes_no_primary(uwsgi, monkeypatch):
+    proc = uwsgi("--enable-threads", "--processes", "2")
+    stdout, _ = proc.communicate()
+    assert (
+        b"ddtrace.internal.uwsgi.uWSGIConfigError: master option must be enabled when multiple processes are used"
+        in stdout
+    )
+
+
+def _get_worker_pids(stdout, num_worker, num_app_started=1):
+    worker_pids = []
+    started = 0
+    while True:
+        line = stdout.readline()
+        if line == b"":
+            break
+        elif b"WSGI app 0 (mountpoint='') ready" in line:
+            started += 1
+        else:
+            m = re.match(r"^spawned uWSGI worker \d+ .*\(pid: (\d+),", line.decode())
+            if m:
+                worker_pids.append(int(m.group(1)))
+
+        if len(worker_pids) == num_worker and num_app_started == started:
+            break
+
+    return worker_pids
+
+
+def test_uwsgi_threads_processes_primary(uwsgi, tmp_path, monkeypatch):
+    filename = str(tmp_path / "uwsgi.pprof")
+    monkeypatch.setenv("DD_PROFILING_OUTPUT_PPROF", filename)
+    proc = uwsgi("--enable-threads", "--master", "--py-call-uwsgi-fork-hooks", "--processes", "2")
+    worker_pids = _get_worker_pids(proc.stdout, 2)
+    # Give some time to child to actually startup
+    time.sleep(3)
+    proc.terminate()
+    assert proc.wait() == 0
+    for pid in worker_pids:
+        profile = pprof_utils.parse_profile("%s.%d" % (filename, pid))
+        samples = pprof_utils.get_samples_with_value_type(profile, "wall-time")
+        assert len(samples) > 0
+
+
+def test_uwsgi_threads_processes_primary_lazy_apps(uwsgi, tmp_path, monkeypatch):
+    filename = str(tmp_path / "uwsgi.pprof")
+    monkeypatch.setenv("DD_PROFILING_OUTPUT_PPROF", filename)
+    monkeypatch.setenv("DD_PROFILING_UPLOAD_INTERVAL", "1")
+    # For uwsgi<2.0.30, --skip-atexit is required to avoid crashes when
+    # the child process exits.
+    proc = uwsgi("--enable-threads", "--master", "--processes", "2", "--lazy-apps", "--skip-atexit")
+    worker_pids = _get_worker_pids(proc.stdout, 2, 2)
+    # Give some time to child to actually startup and output a profile
+    time.sleep(3)
+    proc.terminate()
+    assert proc.wait() == 0
+    for pid in worker_pids:
+        profile = pprof_utils.parse_profile("%s.%d" % (filename, pid))
+        samples = pprof_utils.get_samples_with_value_type(profile, "wall-time")
+        assert len(samples) > 0
+
+
+def test_uwsgi_threads_processes_no_primary_lazy_apps(uwsgi, tmp_path, monkeypatch):
+    filename = str(tmp_path / "uwsgi.pprof")
+    monkeypatch.setenv("DD_PROFILING_OUTPUT_PPROF", filename)
+    monkeypatch.setenv("DD_PROFILING_UPLOAD_INTERVAL", "1")
+    # For uwsgi<2.0.30, --skip-atexit is required to avoid crashes when
+    # the child process exits.
+    proc = uwsgi("--enable-threads", "--processes", "2", "--lazy-apps", "--skip-atexit")
+    worker_pids = _get_worker_pids(proc.stdout, 2, 2)
+    # Give some time to child to actually startup and output a profile
+    time.sleep(3)
+    # The processes are started without a master/parent so killing one does not kill the other:
+    # Kill them all and wait until they die.
+    for pid in worker_pids:
+        os.kill(pid, signal.SIGTERM)
+    # The first worker is our child, we can wait for it "normally"
+    os.waitpid(worker_pids[0], 0)
+    # The other ones are grandchildren, we can't wait for it with `waitpid`
+    for pid in worker_pids[1:]:
+        # Wait for the uwsgi workers to all die
+        while True:
+            try:
+                os.kill(pid, 0)
+            except OSError:
+                break
+    for pid in worker_pids:
+        profile = pprof_utils.parse_profile("%s.%d" % (filename, pid))
+        samples = pprof_utils.get_samples_with_value_type(profile, "wall-time")
+        assert len(samples) > 0