functiontrace 0.3.10__tar.gz → 0.4.2__tar.gz

functiontrace-0.4.2/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "_functiontrace_rs"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+color-eyre = { version = "0.6", default-features = false }
+functiontrace-server = { version = "0.8.4", default-features = false, features = ["serialize"] }
+libc = "0.2"
+pyo3 = { version = "0.24", features = ["eyre"] }
+rmp-serde = "1.3"
+serde = "1"
+
+[build-dependencies]
+toml = { version = "0.8", default-features = false, features = ["parse"] }
+
+[lib]
+# See https://github.com/PyO3/pyo3 for details
+name = "_functiontrace_rs"  # private module to be nested into Python package
+crate-type = ["cdylib"]
+path = "rust/lib.rs"

functiontrace-0.4.2/MANIFEST.in

@@ -0,0 +1,4 @@
+graft mpack
+graft rust
+include Cargo.toml
+include build.rs

{functiontrace-0.3.10/functiontrace.egg-info → functiontrace-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.3.10
+Version: 0.4.2
 Summary: A profiling tool that traces your application's execution
 Author: Alistair Dobke
 Author-email: Matt Bryant <functiontrace@programsareproofs.com>
@@ -16,7 +16,7 @@ Classifier: Environment :: Console
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 
 Py-Functiontrace

functiontrace-0.4.2/_functiontrace.c

@@ -0,0 +1,277 @@
+#include <Python.h>
+#include <frameobject.h>
+#include <sys/types.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <unistd.h>
+
+#include "mpack/mpack.h"
+
+//#include <assert.h>
+// By default, python c extensions compile with asserts disable and it is not
+// super easy to disable this behavior (AFAIK). Use this custom assert for now.
+void assert_helper(int lineno, char* expr) {
+    printf("Assertion failed on line %d: %s\n", lineno, expr);
+    exit(-1);
+}
+#undef assert
+#define assert(expr) \
+    if (!(expr)) \
+        assert_helper(__LINE__, #expr)
+
+////////////////////////////////////////////////////////////////////////////////
+// Types
+////////////////////////////////////////////////////////////////////////////////
+
+// The messagepack writer for the current thread.
+typedef mpack_writer_t Writer;
+
+////////////////////////////////////////////////////////////////////////////////
+// Prototypes
+////////////////////////////////////////////////////////////////////////////////
+static Writer* Fprofile_Writer(void);
+
+static int     Fprofile_FunctionTrace(PyObject* obj, PyFrameObject* frame, int what, PyObject* arg);
+
+////////////////////////////////////////////////////////////////////////////////
+// Globals
+////////////////////////////////////////////////////////////////////////////////
+// This key is used to fetch the thread local instance of the `Writer`
+// structure.
+static pthread_key_t Tss_Key = 0;
+
+// True iff we've started tracing and haven't been marked as terminated.  When
+// this is set, we're allowed to send messages to the profile generation
+// server.
+static bool started;
+
+// The exposed apis of the Rust extension.
+static struct {
+    pthread_key_t (*set_config)(bool* config, int (*functiontrace)(PyObject*, PyFrameObject*, int, PyObject*));
+}* rust;
+
+////////////////////////////////////////////////////////////////////////////////
+// Server Communication
+////////////////////////////////////////////////////////////////////////////////
+
+static Writer* Fprofile_Writer(void) {
+    assert(Tss_Key != 0);
+
+    if (!started) {
+        // We aren't running (either starting up or shutting down), so
+        // shouldn't write anything.
+        return NULL;
+    }
+
+    // Fetch the Writerr for the current thread.  It's created as late as
+    // the first function call for the thread, so we can plausibly get messages
+    // before having anywhere to store/send them to.  Drop them if so - they
+    // weren't too important if we aren't running code yet.
+    Writer* state = pthread_getspecific(Tss_Key);
+    if (state == NULL) {
+        // The thread hasn't officially started yet, so drop this message.
+        return NULL;
+    }
+
+    return state;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Misc
+////////////////////////////////////////////////////////////////////////////////
+
+// Given a PyObject (likely `co_name` or similar), return a UTF-8
+// representation.
+static inline const char* Fprofile_UnicodeToUtf8(PyObject* obj) {
+    if (obj == NULL) {
+        return "<NULL>";
+    }
+
+    if (PyUnicode_Check(obj)) {
+        const char* utf8 = PyUnicode_AsUTF8(obj);
+
+        return utf8 != NULL ? utf8 : "<DECODE ERROR>";
+    } else if (obj == Py_None) {
+        return "<NONE>";
+    } else {
+        return "<UNKNOWN>";
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Callbacks
+////////////////////////////////////////////////////////////////////////////////
+static int Fprofile_FunctionTrace(PyObject* obj, PyFrameObject* frame, int what, PyObject* arg) {
+    PyCFunctionObject* fn  = (PyCFunctionObject*) arg;
+    struct timespec    tsc = { 0 };
+
+    Writer* writer = Fprofile_Writer();
+    if (writer == NULL) {
+        return 0;
+    }
+
+    clock_gettime(CLOCK_MONOTONIC, &tsc);
+
+    switch (what) {
+        case PyTrace_CALL:
+            mpack_start_array(writer, 5);
+            mpack_write_cstr(writer, "Call");
+
+            mpack_start_array(writer, 2);
+            mpack_write_u32(writer, tsc.tv_sec);
+            mpack_write_u32(writer, tsc.tv_nsec);
+            mpack_finish_array(writer);
+
+            {
+                // TODO: Check if frame is none or similar
+#if PY_VERSION_HEX >= 0x030a00a0
+                // Python >= 3.10 should use the standard accessors
+                PyCodeObject* code = PyFrame_GetCode(frame);
+                int lineno = PyFrame_GetLineNumber(frame);
+#else
+                PyCodeObject* code = frame->f_code;
+                int lineno = frame->f_lineno;
+#endif
+
+#if PY_VERSION_HEX >= 0x030b00a0
+                mpack_write_cstr(writer, Fprofile_UnicodeToUtf8(code->co_qualname));
+#else
+                mpack_write_cstr(writer, Fprofile_UnicodeToUtf8(code->co_name));
+#endif
+                mpack_write_cstr(writer, Fprofile_UnicodeToUtf8(code->co_filename));
+                mpack_write_u32(writer, lineno);
+
+#if PY_VERSION_HEX >= 0x030a00a0
+                Py_DECREF(code);
+#endif
+            }
+            mpack_finish_array(writer);
+            break;
+        case PyTrace_RETURN:
+            mpack_start_array(writer, 3);
+            mpack_write_cstr(writer, "Return");
+
+            mpack_start_array(writer, 2);
+            mpack_write_u32(writer, tsc.tv_sec);
+            mpack_write_u32(writer, tsc.tv_nsec);
+            mpack_finish_array(writer);
+
+            {
+#if PY_VERSION_HEX >= 0x030a00a0
+                PyCodeObject* code = PyFrame_GetCode(frame);
+#else
+                PyCodeObject* code = frame->f_code;
+#endif
+#if PY_VERSION_HEX >= 0x030b00a0
+                mpack_write_cstr(writer, Fprofile_UnicodeToUtf8(code->co_qualname));
+#else
+                mpack_write_cstr(writer, Fprofile_UnicodeToUtf8(code->co_name));
+#endif
+
+#if PY_VERSION_HEX >= 0x030a00a0
+                Py_DECREF(code);
+#endif
+            }
+            mpack_finish_array(writer);
+            break;
+        case PyTrace_C_CALL: {
+            mpack_start_array(writer, 4);
+            mpack_write_cstr(writer, "NativeCall");
+
+            mpack_start_array(writer, 2);
+            mpack_write_u32(writer, tsc.tv_sec);
+            mpack_write_u32(writer, tsc.tv_nsec);
+            mpack_finish_array(writer);
+
+            {
+                // Attempt to determine what module/class this function belongs
+                // to.
+                PyObject*   self        = fn->m_self;
+                PyObject*   module      = fn->m_module;
+                const char* name        = fn->m_ml->ml_name;
+                const char* module_name = NULL;
+
+                // Check if we belong to a module, and if not we must be a
+                // method.  We do this order to avoid finding that the object
+                // we belong to is of type module.
+                if (module != NULL) {
+                    if (PyModule_Check(module)) {
+                        module_name = PyModule_GetName(module);
+                    } else if (PyUnicode_Check(module)) {
+                        module_name = PyUnicode_AsUTF8(module);
+                    }
+                } else if (self != NULL) {
+                    // This is a method call on a class.
+                    module_name = self->ob_type->tp_name;
+                }
+
+                mpack_write_cstr(writer, name != NULL ? name : "NULL");
+                mpack_write_cstr(writer, module_name != NULL ? module_name : "NULL");
+            }
+            mpack_finish_array(writer);
+            break;
+        }
+        case PyTrace_C_RETURN:
+            mpack_start_array(writer, 3);
+            mpack_write_cstr(writer, "NativeReturn");
+
+            mpack_start_array(writer, 2);
+            mpack_write_u32(writer, tsc.tv_sec);
+            mpack_write_u32(writer, tsc.tv_nsec);
+            mpack_finish_array(writer);
+
+            {
+                const char* name = fn->m_ml->ml_name;
+                mpack_write_cstr(writer, name != NULL ? name : "NULL");
+            }
+            mpack_finish_array(writer);
+            break;
+        default:
+            // TODO: We should handle exceptions here (or somewhere similar).
+            break;
+    }
+
+    return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Module Initialization
+////////////////////////////////////////////////////////////////////////////////
+
+// The set of methods exposed by this module to Python.
+static PyMethodDef methods[] = {
+    [0] = {NULL, NULL, 0, NULL}
+};
+
+static PyModuleDef module = {
+    PyModuleDef_HEAD_INIT,
+    "_functiontrace",
+    "",
+    -1,
+    methods
+};
+
+PyMODINIT_FUNC PyInit__functiontrace(void) {
+    // Setup our janky Rust dlopen alternative so we can use Rust code.
+    PyObject* rust_mod = PyImport_ImportModule("_functiontrace_rs");
+
+    // Verify that the rust extension loads if we're using it.
+    if (rust_mod == NULL) {
+        perror("Failed to load internal Rust extension");
+        exit(-1);
+    }
+
+    // This returns a pointer to the C API exposed by the Rust module.
+    PyObject* py_c_api = PyObject_GetAttrString(rust_mod, "c_api");
+    assert(py_c_api != NULL);
+    PyObject* c_api = PyObject_CallFunctionObjArgs(py_c_api, NULL);
+
+    // Save the Rust vtable so everyone can access it
+    rust = PyLong_AsVoidPtr(c_api);
+
+    // Share our globals with Rust
+    Tss_Key = rust->set_config(&started, Fprofile_FunctionTrace);
+
+    return PyModule_Create(&module);
+}

functiontrace-0.4.2/build.rs

@@ -0,0 +1,17 @@
+fn main() -> std::io::Result<()> {
+    println!("cargo::rerun-if-changed=pyproject.toml");
+
+    // Read pyproject.toml to expose our version to the Rust extension
+    let pyproject = std::fs::read_to_string("pyproject.toml")?
+        .parse::<toml::Table>()
+        .expect("pyproject.toml is valid toml");
+    let version = pyproject
+        .get("project")
+        .and_then(|p| p.as_table())
+        .and_then(|p| p.get("version"))
+        .and_then(|v| v.as_str())
+        .expect("version field is present in pyproject.toml");
+    println!("cargo::rustc-env=PACKAGE_VERSION={}", version);
+
+    Ok(())
+}

{functiontrace-0.3.10 → functiontrace-0.4.2/functiontrace.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.3.10
+Version: 0.4.2
 Summary: A profiling tool that traces your application's execution
 Author: Alistair Dobke
 Author-email: Matt Bryant <functiontrace@programsareproofs.com>
@@ -16,7 +16,7 @@ Classifier: Environment :: Console
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 
 Py-Functiontrace

{functiontrace-0.3.10 → functiontrace-0.4.2}/functiontrace.egg-info/SOURCES.txt

@@ -1,6 +1,8 @@
+Cargo.toml
 MANIFEST.in
 README.rst
 _functiontrace.c
+build.rs
 functiontrace.py
 pyproject.toml
 setup.py
@@ -11,4 +13,5 @@ functiontrace.egg-info/entry_points.txt
 functiontrace.egg-info/top_level.txt
 mpack/LICENSE
 mpack/mpack.c
-mpack/mpack.h
+mpack/mpack.h
+rust/lib.rs

{functiontrace-0.3.10 → functiontrace-0.4.2}/functiontrace.py

@@ -5,7 +5,8 @@ import sys
 import tempfile
 from importlib import machinery, util
 
-import _functiontrace
+import _functiontrace  # noqa: F401 - this import is load bearing since we need to run code on import
+import _functiontrace_rs as rust
 
 PYTHON_TEMPLATE = """#!/bin/sh
 
@@ -70,9 +71,7 @@ def main():
         action="store_true",
         help="Disable compression of traces, which can be unnecessarily slow if filesize is not a concern.",
     )
-    parser.add_argument(
-        "-v", "--version", action="version", version=_functiontrace.__version__
-    )
+    parser.add_argument("-v", "--version", action="version", version=rust.__version__)
     parser.add_argument("script", nargs=argparse.REMAINDER)
     args = parser.parse_args()
 
@@ -114,8 +113,8 @@ def main():
     if args.no_compression:
         os.environ["FUNCTIONTRACE_COMPRESSION"] = "false"
     if args.trace_memory:
-        _functiontrace.config_tracememory()
-    _functiontrace.begin_tracing(args.output_dir)
+        rust.enable_tracememory()
+    rust.begin_tracing(args.output_dir)
 
     # Run their code now that we're tracing.  This must be done in the context
     # of the __main__ module we've created.
@@ -125,7 +124,7 @@ def main():
 def trace():
     # Make sure we're set up to work properly, then begin tracing.
     setup_dependencies()
-    _functiontrace.begin_tracing(os.getcwd())
+    rust.begin_tracing(os.getcwd())
 
 
 if __name__ == "__main__":

{functiontrace-0.3.10 → functiontrace-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "functiontrace"
-version = "0.3.10"
+version = "0.4.2"
 description = "A profiling tool that traces your application's execution"
 authors = [
     { name = "Matt Bryant", email = "functiontrace@programsareproofs.com"},
@@ -8,13 +8,13 @@ authors = [
 ]
 license = { text = "The Prosperity Public License 3.0.0" }
 readme = "README.rst"
-# NOTE: Actively tested on Python 3.7 - 3.12 and may plausibly break on greater
+# NOTE: Actively tested on Python 3.8 - 3.13 and may plausibly break on greater
 # versions due to C extension hacks.  However, setting a maximum version causes
 # new Python versions to simply install very old versions of Functiontrace that
 # didn't have the `requires-python` annotation on them and are also unlikely to
 # work.  Best to only set the minimum and let bug reports notify us of issues
 # with new Python releases.
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 keywords = [
     "profiler",
     "debugger"
@@ -41,5 +41,9 @@ functiontrace = "functiontrace:main"
 functiontrace = "functiontrace"
 
 [build-system]
-requires = ["setuptools", "toml"]
+requires = ["setuptools", "setuptools-rust"]
 build-backend = "setuptools.build_meta"
+
+[[tool.setuptools-rust.ext-modules]]
+target = "_functiontrace_rs" # Must match `lib.name` in Cargo.toml
+binding = "PyO3"