fix(profiling): ddup support arm, fix import on osx/windows [backport 1.18] (#6670)

Backport d995ad3 from #6529 to 1.18.

The recent libdatadog merge introduced a few issues on various platforms

* arm Linux
* Windows
* macos

This patch
* adds better guards for not-supported platforms
* completes the support for arm-linux
* fixes a bug in the memory profiler when ddup is enabled
* rationalizes the return type of various profiling interfaces to using
a common DDFrame namedtuple (legacy-exporter is not modified for
purposes of stability)
* eliminates the auto-backtrace capability of the ddup exporter; this
was causing issues on some musl distributions and was also interfering
with other tools for native backtraces

## Checklist

- [X] Change(s) are motivated and described in the PR description.
- [X] Testing strategy is described if automated tests are not included
in the PR.
- [X] Risk is outlined (performance impact, potential for breakage,
maintainability, etc).
- [X] Change is maintainable (easy to change, telemetry, documentation).
- [X] [Library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/releasenotes.html)
are followed. If no release note is required, add label
`changelog/no-changelog`.
- [X] Documentation is included (in-code, generated user docs, [public
corp docs](https://github.com/DataDog/documentation/)).
- [X] Backport labels are set (if
[applicable](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting))

## Reviewer Checklist

- [x] Title is accurate.
- [x] No unnecessary changes are introduced.
- [x] Description motivates each change.
- [x] Avoids breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes unless absolutely necessary.
- [x] Testing strategy adequately addresses listed risk(s).
- [x] Change is maintainable (easy to change, telemetry, documentation).
- [x] Release note makes sense to a user of the library.
- [x] Reviewer has explicitly acknowledged and discussed the performance
implications of this PR as reported in the benchmarks PR comment.
- [x] 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)

Co-authored-by: David Sanchez <[email protected]>

Author: github-actions[bot]

ddtrace/internal/datadog/profiling/ddup.pyi renamed to ddtrace/internal/datadog/profiling/_ddup.pyi

@@ -9,7 +9,7 @@ from ddtrace.internal.constants import DEFAULT_SERVICE_NAME
 from ddtrace.span import Span
 
 
-IF UNAME_SYSNAME == "Linux" and UNAME_MACHINE == "x86_64":
+IF UNAME_SYSNAME == "Linux":
     cdef extern from "exporter.hpp":
         ctypedef enum ProfileType "ProfileType":
             CPU         "ProfileType::CPU"

ddtrace/internal/datadog/profiling/ddup.pyx renamed to ddtrace/internal/datadog/profiling/_ddup.pyx

@@ -0,0 +1,86 @@
+try:
+    from ._ddup import * # noqa: F403, F401
+except ImportError:
+    from typing import Optional
+    from typing import Dict
+    from ddtrace.span import Span
+
+    # Decorator for not-implemented
+    def not_implemented(func):
+        def wrapper(*args, **kwargs):
+            raise NotImplementedError("{} is not implemented on this platform".format(func.__name__))
+
+    @not_implemented
+    def init(
+        env,     # type: Optional[str]
+        service, # type: Optional[str]
+        version, # type: Optional[str]
+        tags,    # type: Optional[Dict[str, str]]
+        max_nframes, # type: Optional[int]
+        url,     # type: Optional[str]
+    ):
+        pass
+
+    @not_implemented
+    def start_sample(nframes): # type: (int) -> None
+        pass
+
+    @not_implemented
+    def push_cputime(value, count): # type: (int, int) -> None
+        pass
+
+    @not_implemented
+    def push_walltime(value, count): # type: (int, int) -> None
+        pass
+
+    @not_implemented
+    def push_acquire(value, count): # type: (int, int) -> None
+        pass
+
+    @not_implemented
+    def push_release(value, count): # type: (int, int) -> None
+        pass
+
+    @not_implemented
+    def push_alloc(value, count): # type: (int, int) -> None
+        pass
+
+    @not_implemented
+    def push_heap(value): # type: (int) -> None
+        pass
+
+    @not_implemented
+    def push_lock_name(lock_name): # type: (str) -> None
+        pass
+
+    @not_implemented
+    def push_frame(name, filename, address, line): # type: (str, str, int, int) -> None
+        pass
+
+    @not_implemented
+    def push_threadinfo(thread_id, thread_native_id, thread_name): # type: (int, int, Optional[str]) -> None
+        pass
+
+    @not_implemented
+    def push_taskinfo(task_id, task_name): # type: (int, str) -> None
+        pass
+
+    @not_implemented
+    def push_exceptioninfo(exc_type, count): # type: (type, int) -> None
+        pass
+
+    @not_implemented
+    def push_class_name(class_name): # type: (str) -> None
+        pass
+
+    @not_implemented
+    def push_span(span, endpoint_collection_enabled): # type: (Optional[Span], bool) -> None
+        pass
+
+    @not_implemented
+    def flush_sample(): # type: () -> None
+        pass
+
+    @not_implemented
+    def upload(): # type: () -> None
+        pass

ddtrace/internal/datadog/profiling/ddup.py

@@ -2,13 +2,6 @@
 // under the Apache License Version 2.0. This product includes software
 // developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present
 // Datadog, Inc.
-
-// High-level skip for invalid architectures
-#ifndef __linux__
-#elif __aarch64__
-#elif __i386__
-#else
-
 #include "exporter.hpp"
 #include <iostream>
 
@@ -675,5 +668,3 @@ Profile::push_class_name(std::string_view class_name)
     }
     return true;
 }
-
-#endif

ddtrace/internal/datadog/profiling/src/exporter.cpp

@@ -87,6 +87,7 @@ ddup_config_max_nframes(int max_nframes)
         profile_builder.set_max_nframes(max_nframes);
 }
 
+#if DDUP_BACKTRACE_ENABLE
 inline static void
 print_backtrace()
 {
@@ -116,22 +117,27 @@ print_backtrace()
 
     free(symbols);
 }
+
 static void
 sigsegv_handler(int sig, siginfo_t* si, void* uc)
 {
     (void)uc;
     print_backtrace();
     exit(-1);
 }
+
+#endif
 void
 ddup_init()
 {
     if (!is_initialized) {
+#if DDUP_BACKTRACE_ENABLE
         // Install segfault handler
         struct sigaction sigaction_handlers = {};
         sigaction_handlers.sa_sigaction = sigsegv_handler;
         sigaction_handlers.sa_flags = SA_SIGINFO;
         sigaction(SIGSEGV, &(sigaction_handlers), NULL);
+#endif
 
         g_profile_real[0] = profile_builder.build_ptr();
         g_profile_real[1] = profile_builder.build_ptr();

ddtrace/internal/datadog/profiling/src/interface.cpp

@@ -436,6 +436,12 @@ PyInit__memalloc(void)
     if (m == NULL)
         return NULL;
 
+    // Initialize the DDFrame namedtuple class
+    // Do this early so we don't have complicated cleanup
+    if (!memalloc_ddframe_class_init()) {
+        return NULL;
+    }
+
 #ifdef _PY37_AND_LATER
     if (PyThread_tss_create(&memalloc_reentrant_key) != 0) {
 #else

ddtrace/profiling/collector/_memalloc.c

@@ -1,9 +1,10 @@
 import typing
 
-# (filename, line number, function name)
-FrameType = typing.Tuple[str, int, str]
+from .. import event
 
-StackType = typing.Tuple[FrameType, ...]
+# (filename, line number, function name)
+FrameType = event.DDFrame
+StackType = event.StackTraceType
 
 # (stack, nframe, thread_id)
 TracebackType = typing.Tuple[StackType, int, int]

ddtrace/profiling/collector/_memalloc.pyi

@@ -18,6 +18,39 @@ static PyObject* empty_string = NULL;
 
 #define TRACEBACK_SIZE(NFRAME) (sizeof(traceback_t) + sizeof(frame_t) * (NFRAME - 1))
 
+static PyObject* ddframe_class = NULL;
+
+bool
+memalloc_ddframe_class_init()
+{
+    // If this is double-initialized for some reason, then clean up what we had
+    if (ddframe_class) {
+        Py_DECREF(ddframe_class);
+        ddframe_class = NULL;
+    }
+
+    // Import the module that contains the DDFrame class
+    PyObject* mod_path = PyUnicode_DecodeFSDefault("ddtrace.profiling.event");
+    PyObject* mod = PyImport_Import(mod_path);
+    Py_XDECREF(mod_path);
+    if (mod == NULL) {
+        PyErr_Print();
+        return false;
+    }
+
+    // Get the DDFrame class object
+    ddframe_class = PyObject_GetAttrString(mod, "DDFrame");
+    Py_XDECREF(mod);
+
+    // Basic sanity check that the object is the type of object we actually want
+    if (ddframe_class == NULL || !PyCallable_Check(ddframe_class)) {
+        PyErr_Print();
+        return false;
+    }
+
+    return true;
+}
+
 int
 memalloc_tb_init(uint16_t max_nframe)
 {
@@ -195,14 +228,24 @@ traceback_to_tuple(traceback_t* tb)
         PyTuple_SET_ITEM(frame_tuple, 3, empty_string);
         Py_INCREF(empty_string);
 
+        // Try to set the class.  If we cannot (e.g., if the sofile is reloaded
+        // without module initialization), then this will result in an error if
+        // the underlying object is used via attributes
+        if (ddframe_class) {
+#if PY_VERSION_HEX >= 0x03090000
+            Py_SET_TYPE(frame_tuple, (PyTypeObject*)ddframe_class);
+#else
+            Py_TYPE(frame_tuple) = (PyTypeObject*)ddframe_class;
+#endif
+            Py_INCREF(ddframe_class);
+        }
+
         PyTuple_SET_ITEM(stack, nframe, frame_tuple);
     }
 
     PyObject* tuple = PyTuple_New(3);
-
     PyTuple_SET_ITEM(tuple, 0, stack);
     PyTuple_SET_ITEM(tuple, 1, PyLong_FromUnsignedLong(tb->total_nframe));
     PyTuple_SET_ITEM(tuple, 2, PyLong_FromUnsignedLong(tb->thread_id));
-
     return tuple;
 }

ddtrace/profiling/collector/_memalloc_tb.c

@@ -1,6 +1,7 @@
 #ifndef _DDTRACE_MEMALLOC_TB_H
 #define _DDTRACE_MEMALLOC_TB_H
 
+#include <stdbool.h>
 #include <stdint.h>
 
 #include <Python.h>
@@ -43,6 +44,9 @@ typedef struct
 /* The maximum number of frames we can store in `traceback_t.nframe` */
 #define TRACEBACK_MAX_NFRAME UINT16_MAX
 
+bool
+memalloc_ddframe_class_init();
+
 int
 memalloc_tb_init(uint16_t max_nframe);
 void

ddtrace/profiling/collector/_memalloc_tb.h

@@ -5,5 +5,5 @@ from .. import event
 
 def traceback_to_frames(
     traceback: types.TracebackType, max_nframes: int
-) -> typing.Tuple[typing.List[event.FrameType], int]: ...
-def pyframe_to_frames(frame: types.FrameType, max_nframes: int) -> typing.Tuple[typing.List[event.FrameType], int]: ...
+) -> typing.Tuple[typing.List[event.DDFrame], int]: ...
+def pyframe_to_frames(frame: types.FrameType, max_nframes: int) -> typing.Tuple[typing.List[event.DDFrame], int]: ...