functiontrace 0.5.0__tar.gz → 0.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.5.0
+Version: 0.5.1
 Summary: A profiling tool that traces your application's execution
 Author: Alistair Dobke
 Author-email: Matt Bryant <functiontrace@programsareproofs.com>

{functiontrace-0.5.0 → functiontrace-0.5.1}/build.rs

@@ -5,14 +5,24 @@ fn main() -> std::io::Result<()> {
     let pyproject = std::fs::read_to_string("pyproject.toml")?
         .parse::<toml::Table>()
         .expect("pyproject.toml is valid toml");
-    let version = pyproject
+    let project = pyproject
         .get("project")
         .and_then(|p| p.as_table())
-        .and_then(|p| p.get("version"))
+        .expect("project field is present in pyproject.toml");
+
+    let version = project
+        .get("version")
         .and_then(|v| v.as_str())
         .expect("version field is present in pyproject.toml");
     println!("cargo::rustc-env=PACKAGE_VERSION={}", version);
 
+    let min_python = project
+        .get("requires-python")
+        .and_then(|v| v.as_str())
+        .and_then(|v| v.strip_prefix(">=3."))
+        .expect("requires-python field is present in pyproject.toml");
+    println!("cargo::rustc-env=MIN_PYTHON_VERSION={}", min_python);
+
     // Figure out which Python version we're building for
     pyo3_build_config::use_pyo3_cfgs();
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.5.0
+Version: 0.5.1
 Summary: A profiling tool that traces your application's execution
 Author: Alistair Dobke
 Author-email: Matt Bryant <functiontrace@programsareproofs.com>

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

@@ -27,7 +27,8 @@ def setup_dependencies():
     # Generate wrappers for the various Python versions we support to ensure
     # they're included in our PATH.
     wrap_pythons = ["python", "python3"] + [
-        "python3.{}".format(minor) for minor in range(6, 13)
+        "python3.{}".format(minor)
+        for minor in range(rust._min_python_version, rust._max_python_version + 1)
     ]
     for python in wrap_pythons:
         with open(os.path.join(tempdir, python), "w") as f:

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

@@ -1,6 +1,6 @@
 [project]
 name = "functiontrace"
-version = "0.5.0"
+version = "0.5.1"
 description = "A profiling tool that traces your application's execution"
 authors = [
     { name = "Matt Bryant", email = "functiontrace@programsareproofs.com"},

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

@@ -195,10 +195,20 @@ mod _functiontrace_rs {
     /// Initialization code run on this module's import (mostly useful for adding constants)
     #[pymodule_init]
     fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
-        // Arbitrary code to run at the module initialization
         m.add("__version__", env!("PACKAGE_VERSION"))
             .wrap_err("Failed to expose PACKAGE_VERSION")?;
 
+        // Expose the minimum and maximum Python 3 versions we support
+        m.add(
+            "_min_python_version",
+            env!("MIN_PYTHON_VERSION")
+                .parse::<u32>()
+                .wrap_err("Failed to convert MIN_PYTHON_VERSION to int")?,
+        )
+        .wrap_err("Failed to expose _min_python_version")?;
+        m.add("_max_python_version", 13)
+            .wrap_err("Failed to expose _max_python_version")?;
+
         color_eyre::install().wrap_err("Failed to install color_eyre")?;
 
         // If someone else has already installed a tracing subscriber, we'll fail to initialize
@@ -244,6 +254,57 @@ mod _functiontrace_rs {
             return Err(eyre!("FunctionTrace is already initialized!"));
         }
 
+        // Store the processes' args, since threads will need it as part of the registration message.
+        ARGV.set({
+            // 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> {
+                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>()
+                    .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>()
+                        .map_err(|e| eyre!("Failed to read sys.argv[x] as string: {}", e))
+                        .and_then(|arg| {
+                            arg.to_str()
+                                .wrap_err("Failed to read Rust string out of PyString")
+                        })
+                        .unwrap_or("<UNKNOWN>");
+
+                    s + " " + arg
+                });
+
+                // We'll display this in the UI, so ensure it's under (the rather
+                // arbitrary) 100 chars.
+                if full_args.chars().count() > 95 {
+                    full_args.truncate(95);
+                    full_args.push_str(" ...");
+                }
+
+                // We'll be cloning this
+                full_args.shrink_to_fit();
+                Ok(full_args)
+            })
+            .unwrap_or_else(|_err| {
+                tracing::warn!("Failed to read ARGV");
+
+                "<UNKNOWN>".into()
+            })
+        })
+        .expect("ARGV is only set in `trace_initialization`");
+
+        /////////////////////////////////////////////////////////////////////////
+        // Server initialization
+        /////////////////////////////////////////////////////////////////////////
         // Check if we're in a subprocess of a command being run under functiontrace.  If we are,
         // we should connect to the same socket.  Otherwise, we should setup the full profiling
         // configuration ourselves.
@@ -253,155 +314,105 @@ mod _functiontrace_rs {
             SOCKADDR
                 .set(existing_sockaddr)
                 .expect("sockaddr is only set in `trace_initialization`");
-            return Ok(());
-        }
+        } else {
+            // Launch the functiontrace-server as a daemon, then record the address of the socket we'll
+            // need to communicate with it on.
+            let sockaddr = {
+                let server = match std::process::Command::new("functiontrace-server")
+                    .arg("--directory")
+                    .arg(output_directory)
+                    .spawn()
+                {
+                    Ok(server) => server,
+                    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."
+                        );
 
-        // Launch the functiontrace-server as a daemon, then record the address of the socket we'll
-        // need to communicate with it on.
-        let sockaddr = {
-            let server = match std::process::Command::new("functiontrace-server")
-                .arg("--directory")
-                .arg(output_directory)
-                .spawn()
-            {
-                Ok(server) => server,
-                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."
-                    );
+                        // Exit here rather than returning an error, since that'll emit a confusing
+                        // Python stacktrace.
+                        std::process::exit(1);
+                    }
+                    e => e.wrap_err("Failed to launch functiontrace-server")?,
+                };
 
-                    // Exit here rather than returning an error, since that'll emit a confusing
-                    // Python stacktrace.
-                    std::process::exit(1);
-                }
-                e => e.wrap_err("Failed to launch functiontrace-server")?,
+                format!("/tmp/functiontrace-server.sock.{}", server.id()).into()
             };
 
-            format!("/tmp/functiontrace-server.sock.{}", server.id()).into()
-        };
+            Python::with_gil(|_| {
+                // 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
+                    // way to enforce this.
+                    //
+                    // This doesn't seem to blow up in C even when we don't have the GIL, so
+                    // it's hopefully good enough in practice since there's not really an alternative.
+                    std::env::set_var(BREADCRUMB, &sockaddr);
+                }
+            });
 
-        Python::with_gil(|_| {
-            // 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
-                // way to enforce this.
-                //
-                // This doesn't seem to blow up in C even when we don't have the GIL, so
-                // it's hopefully good enough in practice since there's not really an alternative.
-                std::env::set_var(BREADCRUMB, &sockaddr);
-            }
-        });
+            // Store the server's address so our threads know how to talk to it.
+            SOCKADDR
+                .set(sockaddr)
+                .expect("sockaddr is only set in `trace_initialization`");
 
-        // Store the server's address so our threads know how to talk to it.
-        SOCKADDR
-            .set(sockaddr)
-            .expect("sockaddr is only set in `trace_initialization`");
-
-        // 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 argv = {
-                // 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.
-                let args_prefix = Python::with_gil(|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>()
-                        .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>()
-                            .map_err(|e| eyre!("Failed to read sys.argv[x] as string: {}", e))
-                            .and_then(|arg| {
-                                arg.to_str()
-                                    .wrap_err("Failed to read Rust string out of PyString")
-                            })
-                            .unwrap_or("<UNKNOWN>");
-
-                        s + " " + arg
-                    });
-
-                    // We'll display this in the UI, so ensure it's under (the rather
-                    // arbitrary) 100 chars.
-                    if full_args.chars().count() > 95 {
-                        full_args.truncate(95);
-                        full_args.push_str(" ...");
-                    }
+            // 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 version = py.version_info();
+
+                    format!(
+                        "Python {}.{}.{}",
+                        version.major, version.minor, version.patch
+                    )
+                });
 
-                    // We'll be cloning this
-                    full_args.shrink_to_fit();
-                    Ok(full_args)
+                let platform = Python::with_gil(|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>()
+                        .map_err(|e| eyre!("Failed to read sys.platform as string: {}", e))?
+                        .to_str()
+                        .wrap_err("Failed to read Rust string out of PyString")?
+                        .into())
                 })
                 .unwrap_or_else(|_err| {
-                    tracing::warn!("Failed to read ARGV");
+                    tracing::warn!("Failed to read sys.platform");
 
                     "<UNKNOWN>".into()
                 });
 
-                // Store the args, since threads will need it as part of the registration message.
-                ARGV.set(args_prefix.clone())
-                    .expect("ARGV is only set in `trace_initialization`");
-
-                args_prefix
+                function_trace::TraceInitialization {
+                    program_name: ARGV
+                        .get()
+                        .expect("ARGV is set earlier in trace_initialization")
+                        .clone(),
+                    program_version: format!("py-functiontrace {}", env!("PACKAGE_VERSION")),
+                    lang_version: python_version,
+                    platform,
+                    time: trace_time(),
+                }
             };
 
-            let python_version = Python::with_gil(|py| {
-                let version = py.version_info();
-
-                format!(
-                    "Python {}.{}.{}",
-                    version.major, version.minor, version.patch
-                )
-            });
-
-            let platform = Python::with_gil(|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>()
-                    .map_err(|e| eyre!("Failed to read sys.platform as string: {}", e))?
-                    .to_str()
-                    .wrap_err("Failed to read Rust string out of PyString")?
-                    .into())
-            })
-            .unwrap_or_else(|_err| {
-                tracing::warn!("Failed to read sys.platform");
-
-                "<UNKNOWN>".into()
-            });
-
-            function_trace::TraceInitialization {
-                program_name: argv,
-                program_version: format!("py-functiontrace {}", env!("PACKAGE_VERSION")),
-                lang_version: python_version,
-                platform,
-                time: trace_time(),
-            }
-        };
-
-        let mut socket = message_initialize();
+            let mut socket = message_initialize();
 
-        init.serialize(&mut rmp_serde::encode::Serializer::new(&mut socket))
-            .wrap_err("Failed to emit TraceInitialization message")?;
+            init.serialize(&mut rmp_serde::encode::Serializer::new(&mut socket))
+                .wrap_err("Failed to emit TraceInitialization message")?;
 
-        // Close the initialization socket to trigger `functiontrace-server` to
-        // read our message, since otherwise it'll wait forever for more data.
-        socket
-            .shutdown(std::net::Shutdown::Both)
-            .wrap_err("Failed to close initialization socket")?;
+            // Close the initialization socket to trigger `functiontrace-server` to
+            // read our message, since otherwise it'll wait forever for more data.
+            socket
+                .shutdown(std::net::Shutdown::Both)
+                .wrap_err("Failed to close initialization socket")?;
+        }
 
         ////////////////////////////////////////////////////////////////////////////
         // Teardown Configuration