functiontrace 0.5.1__tar.gz → 0.5.3__tar.gz

{functiontrace-0.5.1 → functiontrace-0.5.3}/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "_functiontrace_rs"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 color-eyre = { version = "0.6", default-features = false }
@@ -10,17 +10,17 @@ functiontrace-server = { version = "0.8.4", default-features = false, features =
 jiff = { version = "0.2", default-features = false, features = ["std", "serde"] }
 libc = "0.2"
 owo-colors = "4.2"
-pyo3 = { version = "0.25", features = ["eyre"] }
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
+pyo3 = { version = "0.29", features = ["eyre"] }
+reqwest = { version = "0.13", default-features = false, features = ["blocking", "json", "rustls"] }
 rmp-serde = "1.3"
 serde = "1"
-toml = "0.9"
+toml = "1.1"
 tracing = { version = "0.1", features = ["log"] }
 tracing-subscriber = { version = "0.3", default-features = false, features = ["ansi", "env-filter", "fmt", "std"] }
 
 [build-dependencies]
-toml = { version = "0.9", default-features = false, features = ["parse", "serde"] }
-pyo3-build-config = { version = "0.25", features = ["resolve-config"] }
+toml = { version = "1.1", default-features = false, features = ["parse", "serde"] }
+pyo3-build-config = { version = "0.29" }
 
 [lib]
 # See https://github.com/PyO3/pyo3 for details

{functiontrace-0.5.1/functiontrace.egg-info → functiontrace-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.5.1
+Version: 0.5.3
 Summary: A profiling tool that traces your application's execution
 Author: Alistair Dobke
 Author-email: Matt Bryant <functiontrace@programsareproofs.com>
@@ -15,7 +15,7 @@ Classifier: Environment :: Console
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.md
 Dynamic: license-file
@@ -28,7 +28,7 @@ Dependencies
 ------------
 
 The FunctionTrace server must be installed for this package to work.
-See installation instructions at https://functiontrace.com#installation.
+See installation instructions at https://functiontrace.com/installation/.
 
 Usage
 -----

{functiontrace-0.5.1 → functiontrace-0.5.3}/README.rst

@@ -6,7 +6,7 @@ Dependencies
 ------------
 
 The FunctionTrace server must be installed for this package to work.
-See installation instructions at https://functiontrace.com#installation.
+See installation instructions at https://functiontrace.com/installation/.
 
 Usage
 -----

{functiontrace-0.5.1 → functiontrace-0.5.3/functiontrace.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.5.1
+Version: 0.5.3
 Summary: A profiling tool that traces your application's execution
 Author: Alistair Dobke
 Author-email: Matt Bryant <functiontrace@programsareproofs.com>
@@ -15,7 +15,7 @@ Classifier: Environment :: Console
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.md
 Dynamic: license-file
@@ -28,7 +28,7 @@ Dependencies
 ------------
 
 The FunctionTrace server must be installed for this package to work.
-See installation instructions at https://functiontrace.com#installation.
+See installation instructions at https://functiontrace.com/installation/.
 
 Usage
 -----

{functiontrace-0.5.1 → functiontrace-0.5.3}/functiontrace.egg-info/SOURCES.txt

@@ -11,4 +11,5 @@ functiontrace.egg-info/SOURCES.txt
 functiontrace.egg-info/dependency_links.txt
 functiontrace.egg-info/entry_points.txt
 functiontrace.egg-info/top_level.txt
-rust/lib.rs
+rust/lib.rs
+rust/multiprocessing.sh.tpl

{functiontrace-0.5.1 → functiontrace-0.5.3}/functiontrace.py

@@ -19,7 +19,12 @@ exec $(which {python}) -m functiontrace "$@"
 
 
 def setup_dependencies():
-    # Generate a temp directory to store our wrappers in.  We'll temporarily
+    if f"{tempfile.gettempdir()}/py-functiontrace" in os.environ["PATH"]:
+        # We've already set up dependencies. This only needs to happen once, since otherwise we'll
+        # just make a bunch of useless temp directories.
+        return
+
+    # Generate a temp directory to store our wrappers in. We'll temporarily
     # add this directory to our path.
     tempdir = tempfile.mkdtemp(prefix="py-functiontrace")
     os.environ["PATH"] = tempdir + os.pathsep + os.environ["PATH"]
@@ -89,10 +94,19 @@ def main():
     # below, which needs to operate in the context of our new module.
     # NOTE: We use SourceFileLoader, rather than allowing importlib to infer
     # the proper loader, in order to support files without a .py extension.
-    spec = util.spec_from_loader(
-        "__main__", machinery.SourceFileLoader("__main__", target_file)
+    mod = util.module_from_spec(
+        util.spec_from_loader(
+            "__main__", machinery.SourceFileLoader("__main__", target_file)
+        )
     )
-    mod = util.module_from_spec(spec)
+
+    # Clear __spec__ to match Python's standard `python foo.py` loading
+    mod.__spec__ = None
+    # Record the file we're using so `multiprocessing` can load it (in a non-forked context).
+    # Without this, `multiprocessing` in `forkserver` contexts is asked to load functions that
+    # it can't find.
+    mod.__file__ = target_file
+
     sys.modules.update({"__main__": mod})
 
     # Ensure we're setup to be able to run.

{functiontrace-0.5.1 → functiontrace-0.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "functiontrace"
-version = "0.5.1"
+version = "0.5.3"
 description = "A profiling tool that traces your application's execution"
 authors = [
     { name = "Matt Bryant", email = "functiontrace@programsareproofs.com"},
@@ -9,13 +9,13 @@ authors = [
 license = "LicenseRef-Prosperity-Public-License-3.0.0"
 license-files = ["LICENSE.md"]
 readme = "README.rst"
-# NOTE: Actively tested on Python 3.9 - 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.9"
+# NOTE: Actively tested on Python 3.10 - 3.14 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.10"
 keywords = [
     "profiler",
     "debugger"

{functiontrace-0.5.1 → functiontrace-0.5.3}/rust/lib.rs

@@ -7,7 +7,7 @@ mod _functiontrace_rs {
     use serde::{Deserialize, Serialize};
     use std::borrow::Cow;
     use std::cell::Cell;
-    use std::ffi::{CStr, OsString, c_void};
+    use std::ffi::{CStr, OsString};
     use std::io::Write;
     use std::os::unix::net::UnixStream;
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -148,7 +148,7 @@ mod _functiontrace_rs {
         let state = THREAD_STATE.get();
 
         if state.is_null() {
-            // We shouldn't be asked to reset at thread that hasn't yet been registered.
+            // We shouldn't be asked to reset a thread that hasn't yet been registered.
             return None;
         }
 
@@ -206,7 +206,7 @@ mod _functiontrace_rs {
                 .wrap_err("Failed to convert MIN_PYTHON_VERSION to int")?,
         )
         .wrap_err("Failed to expose _min_python_version")?;
-        m.add("_max_python_version", 13)
+        m.add("_max_python_version", 14)
             .wrap_err("Failed to expose _max_python_version")?;
 
         color_eyre::install().wrap_err("Failed to install color_eyre")?;
@@ -241,6 +241,8 @@ mod _functiontrace_rs {
         module: &Bound<'_, PyModule>,
         output_directory: OsString,
     ) -> Result<()> {
+        use std::os::unix::fs::{DirBuilderExt, PermissionsExt};
+
         // The name of the env var we use to notify subprocesses that there's a trace in progress.
         const BREADCRUMB: &str = "FUNCTIONTRACE_LIVE";
 
@@ -259,20 +261,20 @@ mod _functiontrace_rs {
             // Parse args out of `sys.argv`, since it excludes the Python executable and shows the
             // script's path first.  This is much more complicated than using `std::env::args`, but
             // is more practical.
-            Python::with_gil(|py| -> Result<String> {
+            Python::attach(|py| -> Result<String> {
                 let argv = py
                     .import("sys")
                     .and_then(|sys| sys.getattr("argv"))
                     .wrap_err("Failed to access sys.argv")?;
 
                 let args = argv
-                    .downcast::<pyo3::types::PyList>()
+                    .cast::<pyo3::types::PyList>()
                     .map_err(|e| eyre!("Failed to read sys.argv as list: {}", e))?;
 
                 let mut full_args = args.iter().fold(String::new(), |s, arg| {
                     // Fetch the next arg as a string if possible.
                     let arg = arg
-                        .downcast::<pyo3::types::PyString>()
+                        .cast::<pyo3::types::PyString>()
                         .map_err(|e| eyre!("Failed to read sys.argv[x] as string: {}", e))
                         .and_then(|arg| {
                             arg.to_str()
@@ -327,7 +329,7 @@ mod _functiontrace_rs {
                     Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
                         eprintln!("Unable to find `functiontrace-server` in the current $PATH.");
                         eprintln!(
-                            "See https://functiontrace.com#installation for installation instructions."
+                            "See https://functiontrace.com/installation/ for installation instructions."
                         );
 
                         // Exit here rather than returning an error, since that'll emit a confusing
@@ -337,15 +339,24 @@ mod _functiontrace_rs {
                     e => e.wrap_err("Failed to launch functiontrace-server")?,
                 };
 
-                format!("/tmp/functiontrace-server.sock.{}", server.id()).into()
+                let sockaddr = format!("/tmp/functiontrace-server.sock.{}", server.id());
+
+                // Also allocate a directory for storing wrappers (multiprocessing.set_executable,
+                // etc) we may need.
+                std::fs::DirBuilder::new()
+                    .recursive(true)
+                    .mode(0o700)
+                    .create(format!("{sockaddr}.wrappers"))
+                    .wrap_err("Failed to create wrapper directory")?;
+                sockaddr.into()
             };
 
-            Python::with_gil(|_| {
+            Python::attach(|_| {
                 // Register an env var so subprocesses know how to connect to our
                 // profile.
                 unsafe {
                     // SAFETY: `set_var` can only be done while no one else is reading or writing to the
-                    // environment.  We're holding the GIL, so this _should_ be true, but there's no real
+                    // environment. We're holding the GIL, so this _should_ be true, but there's no real
                     // way to enforce this.
                     //
                     // This doesn't seem to blow up in C even when we don't have the GIL, so
@@ -362,7 +373,7 @@ mod _functiontrace_rs {
             // Send an initialization message to the server with some information about us.  This will
             // only be sent once, and all future threads/subprocesses will be associated underneath us.
             let init = {
-                let python_version = Python::with_gil(|py| {
+                let python_version = Python::attach(|py| {
                     let version = py.version_info();
 
                     format!(
@@ -371,14 +382,14 @@ mod _functiontrace_rs {
                     )
                 });
 
-                let platform = Python::with_gil(|py| -> Result<String> {
+                let platform = Python::attach(|py| -> Result<String> {
                     let platform = py
                         .import("sys")
                         .and_then(|sys| sys.getattr("platform"))
                         .wrap_err("Failed to access sys.platform")?;
 
                     Ok(platform
-                        .downcast::<pyo3::types::PyString>()
+                        .cast::<pyo3::types::PyString>()
                         .map_err(|e| eyre!("Failed to read sys.platform as string: {}", e))?
                         .to_str()
                         .wrap_err("Failed to read Rust string out of PyString")?
@@ -414,6 +425,61 @@ mod _functiontrace_rs {
                 .wrap_err("Failed to close initialization socket")?;
         }
 
+        // `multiprocessing` uses an absolute path to an executable to launch forkserver workers
+        // using `-c` for the actual code,
+        // Override this with our own wrapper that also sets up functiontrace.
+        Python::attach(|py| -> Result<()> {
+            let executable: String = py.import("sys")?.getattr("executable")?.extract()?;
+            let wrapper = {
+                // We'll store the wrappers next to the socket.
+                // TODO: Ideally we'd have these all in the same tmpdir, but that requires changing
+                // client and server code so would be a breaking change.
+                let mut directory = SOCKADDR
+                    .get()
+                    .expect("sockaddr is set during server initialization")
+                    .clone();
+                directory.push(".wrappers");
+
+                std::path::PathBuf::from(directory)
+                    .join("multiprocessing")
+                    .join(executable.strip_prefix("/").unwrap_or(&executable))
+            };
+
+            // Create a multiprocessing wrapper for the current executable if it doesn't exist yet.
+            std::fs::create_dir_all(
+                wrapper
+                    .parent()
+                    .expect("Wrappers are always in a subdirectory"),
+            )
+            .wrap_err("Failed to create multiprocessing wrapper directories")?;
+
+            match std::fs::OpenOptions::new()
+                .write(true)
+                .create_new(true)
+                .open(&wrapper)
+            {
+                Ok(mut file) => {
+                    let script = include_str!("multiprocessing.sh.tpl").replace(
+                        "@PYTHON_INTERPRETER@",
+                        // NOTE: This is equivalent to shlex.quote
+                        &format!("'{}'", executable.replace('\'', "'\"'\"'")),
+                    );
+
+                    file.write_all(script.as_bytes())
+                        .wrap_err("Failed to write multiprocessing wrapper")?;
+                    file.set_permissions(std::fs::Permissions::from_mode(0o700))
+                        .wrap_err("Failed to `chmod +x` multiprocessing wrapper")?;
+                }
+                Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {}
+                Err(err) => return Err(err).wrap_err("Failed to create multiprocessing wrapper"),
+            }
+            py.import("multiprocessing")?
+                .getattr("set_executable")?
+                .call1((wrapper,))?;
+            Ok(())
+        })
+        .wrap_err("Failed to configure multiprocessing tracing")?;
+
         ////////////////////////////////////////////////////////////////////////////
         // Teardown Configuration
         ////////////////////////////////////////////////////////////////////////////
@@ -433,7 +499,7 @@ mod _functiontrace_rs {
         //
         // NOTE: We specifically do this rather than `Py_AtExit`  since we want to run before all
         // the Python teardown occurs.
-        Python::with_gil(|py| -> Result<()> {
+        Python::attach(|py| -> Result<()> {
             py.import("atexit")
                 .and_then(|atexit| atexit.getattr("register"))
                 .wrap_err("Failed to access atexit.register")?
@@ -460,12 +526,13 @@ mod _functiontrace_rs {
 
         // Register our tracing functions with Python - both the normal one and the multithreaded
         // setup trampoline.
+        // TODO: PyEval_SetProfileAllThreads in >=3.12 should simplify this.
         unsafe {
             // SAFETY: both parameters are of the proper type.
             pyo3::ffi::PyEval_SetProfile(Some(functiontrace), std::ptr::null_mut())
         };
 
-        Python::with_gil(|py| -> Result<()> {
+        Python::attach(|py| -> Result<()> {
             py.import("threading")
                 .and_then(|threading| threading.getattr("setprofile"))
                 .wrap_err("Failed to access threading.setprofile")?
@@ -561,23 +628,6 @@ mod _functiontrace_rs {
         Ok(())
     }
 
-    #[unsafe(no_mangle)]
-    extern "C" fn c_thread_teardown(state: *mut c_void) {
-        if state.is_null() {
-            // We never fully initialized this thread, so skip teardown.
-            return;
-        }
-
-        let writer = unsafe {
-            // SAFETY: writer is a valid pointer to an initialized `ThreadState`.
-            &mut (state as *mut ThreadState)
-                .as_mut()
-                .expect("state is non-null")
-        };
-
-        thread_teardown(writer).expect("Failed to tear down FunctionTrace thread")
-    }
-
     /// Tear down the given thread by flushing any outstanding messages.
     ///
     /// This is called when the thread has shut down, including in multithread/process situations.
@@ -636,7 +686,11 @@ mod _functiontrace_rs {
     /// thread state, before replacing itself with the normal Fprofile_FunctionTrace handler.
     #[pyfunction]
     #[pyo3(name = "_thread_trace_trampoline")]
-    fn thread_trace_trampoline(_frame: PyObject, _event: PyObject, _arg: PyObject) -> Result<()> {
+    fn thread_trace_trampoline(
+        _frame: Py<PyAny>,
+        _event: Py<PyAny>,
+        _arg: Py<PyAny>,
+    ) -> Result<()> {
         // Register the current thread for tracing
         thread_register().wrap_err("Failed to register new FunctionTrace thread")?;
 
@@ -787,7 +841,7 @@ mod _functiontrace_rs {
                         pyo3::ffi::PyFrame_GetCode(frame) as *mut pyo3::ffi::PyObject
                     };
 
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                         let code = unsafe {
                             // SAFETY: code is guaranteed to be a valid PyCodeObject since it
                             // came from `PyFrame_GetCode`.
@@ -799,7 +853,7 @@ mod _functiontrace_rs {
                         let unicode_converter = |pyobj: PyResult<Bound<'_, PyAny>>| {
                             pyobj
                                 .map(|obj| {
-                                    if let Ok(filename) = obj.downcast::<pyo3::types::PyString>() {
+                                    if let Ok(filename) = obj.cast::<pyo3::types::PyString>() {
                                         Cow::from(filename.to_string_lossy().into_owned())
                                     } else {
                                         Cow::Borrowed("<UNKNOWN>")
@@ -856,13 +910,13 @@ mod _functiontrace_rs {
                 if !func.m_module.is_null() {
                     // NOTE: _Typically_ `m_module` is a PyModule, but there are no requirements on
                     // what type it needs to be!  In practice, we only see PyModules and PyStrings.
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                         let m_module = unsafe {
                             // SAFETY: m_module is a non-NULL pointer to a valid Python object.
                             Bound::from_borrowed_ptr(py, func.m_module)
                         };
 
-                        if let Ok(module) = m_module.downcast::<pyo3::types::PyModule>() {
+                        if let Ok(module) = m_module.cast::<pyo3::types::PyModule>() {
                             // This is a PyModule, so get its name if possible.
                             let name = module.name();
                             let module_name = if let Ok(name) = &name {
@@ -879,7 +933,7 @@ mod _functiontrace_rs {
                             .serialize(&mut rmp_serde::encode::Serializer::new(&mut writer))
                         } else {
                             let module_name =
-                                if let Ok(module) = m_module.downcast::<pyo3::types::PyString>() {
+                                if let Ok(module) = m_module.cast::<pyo3::types::PyString>() {
                                     module.to_cow().unwrap_or(Cow::Borrowed("<invalid string>"))
                                 } else {
                                     if let Ok(typ) = m_module.get_type().qualname().map(|x| x.to_string()) {
@@ -1125,7 +1179,7 @@ mod _functiontrace_rs {
                     if let Some(result) = parser(&input) {
                         return Ok(result);
                     }
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                         // We need to check with the Python interpreter during loops, otherwise we
                         // might not receive ctrl-c events.
                         py.check_signals()
@@ -1507,7 +1561,7 @@ mod hooks {
     /// function, then attaching enough information about the original function to call it.
     pub fn install() -> Result<()> {
         for hook in HOOKS.iter() {
-            Python::with_gil(|py| -> Result<()> {
+            Python::attach(|py| -> Result<()> {
                 let (module_name, method_name) = hook
                     .target
                     .rsplit_once(".")
@@ -1649,14 +1703,14 @@ mod hooks {
             .get()
             .expect("Wrapper functions can't be called until hooked");
 
-        let proxied = Python::with_gil(|py| -> Result<()> {
+        let proxied = Python::attach(|py| -> Result<()> {
             if let Some(mut writer) = crate::_functiontrace_rs::thread_state() {
                 let args = unsafe {
                     // SAFETY: `args` represents a valid argument tuple
                     Bound::from_borrowed_ptr(py, args)
                 };
                 let args = args
-                    .downcast()
+                    .cast()
                     .map_err(Into::<PyErr>::into)
                     .wrap_err("Python args must be a tuple")?;
 
@@ -1733,7 +1787,7 @@ mod hooks {
                 // `import` takes rather complicated arguments, but in practice we only care about
                 // the first argument (name)
                 let module = if let Ok(arg) = args.get_item(0) {
-                    arg.downcast()
+                    arg.cast()
                         .map_err(Into::into)
                         .and_then(|module| module.to_str())
                         .map(|module| Cow::Owned(module.to_string()))

functiontrace-0.5.3/rust/multiprocessing.sh.tpl

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# Multiprocessing passes the code to execute in workers as `-c <code>`.
+# Strip that out and run tracing setup first, maintaining the order of arguments just in case.
+
+remaining=$#
+while [ "$remaining" -gt 0 ]; do
+    arg=$1
+    shift
+    remaining=$((remaining - 1))
+    case "$arg" in
+        -W|-X)
+            # These arguments can consume other arguments. Skip them so we don't parse the wrong `-c`.
+            value=$1
+            shift
+            remaining=$((remaining - 1))
+            set -- "$@" "$arg" "$value"
+            ;;
+        -c)
+            code=$1
+            shift
+            remaining=$((remaining - 1))
+            set -- "$@" -c '
+exec(
+    (
+        compile(
+            __import__("sys").argv.pop(1),
+            "<string>",
+            "exec",
+            dont_inherit=True,
+        ),
+        # Start tracing before exec runs the compiled code.
+        __import__("_functiontrace_rs").begin_tracing("."),
+    )[0]
+)
+' "$code"
+            break
+            ;;
+        *)
+            set -- "$@" "$arg"
+            ;;
+    esac
+done
+
+# Consume the rest of the args without looking.
+while [ "$remaining" -gt 0 ]; do
+    arg=$1
+    shift
+    remaining=$((remaining - 1))
+    set -- "$@" "$arg"
+done
+
+exec @PYTHON_INTERPRETER@ "$@"