functiontrace 0.4.4__tar.gz → 0.5.1__tar.gz

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

@@ -7,13 +7,19 @@ edition = "2021"
 color-eyre = { version = "0.6", default-features = false }
 dashmap = "6"
 functiontrace-server = { version = "0.8.4", default-features = false, features = ["serialize"] }
+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"] }
 rmp-serde = "1.3"
 serde = "1"
+toml = "0.9"
+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.8", default-features = false, features = ["parse"] }
+toml = { version = "0.9", default-features = false, features = ["parse", "serde"] }
 pyo3-build-config = { version = "0.25", features = ["resolve-config"] }
 
 [lib]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.4.4
+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.4.4 → 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.4.4 → functiontrace-0.5.1/functiontrace.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.4.4
+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.4.4 → functiontrace-0.5.1}/functiontrace.py

@@ -1,6 +1,5 @@
 import argparse
 import os
-import shutil
 import sys
 import tempfile
 from importlib import machinery, util
@@ -20,19 +19,6 @@ exec $(which {python}) -m functiontrace "$@"
 
 
 def setup_dependencies():
-    # We need the functiontrace-server installed and locatable in order to
-    # trace anything.
-    if shutil.which("functiontrace-server") is None:
-        print(
-            "Unable to find `functiontrace-server` in the current $PATH.",
-            file=sys.stderr,
-        )
-        print(
-            "See https://functiontrace.com#installation for installation instructions.",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
     # Generate a temp directory to store our wrappers in.  We'll temporarily
     # add this directory to our path.
     tempdir = tempfile.mkdtemp(prefix="py-functiontrace")
@@ -41,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:
@@ -79,6 +66,9 @@ def main():
         parser.print_help()
         sys.exit(1)
 
+    # Load our config and verify the license before we trace.
+    rust.load_config()
+
     # Ignore ourselves, keeping sys.argv looking reasonable as the child script
     # will expect it to be sane.
     sys.argv[:] = args.script

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

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

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

@@ -1,12 +1,13 @@
 #[pyo3::pymodule]
 mod _functiontrace_rs {
-    use color_eyre::eyre::{eyre, OptionExt, Result, WrapErr};
+    use color_eyre::eyre::{OptionExt, Result, WrapErr, eyre};
     use functiontrace_server::function_trace;
-    use pyo3::prelude::*; // TODO: What's in here?
-    use serde::Serialize;
+    use jiff::Timestamp;
+    use pyo3::prelude::*;
+    use serde::{Deserialize, Serialize};
     use std::borrow::Cow;
     use std::cell::Cell;
-    use std::ffi::{c_void, CStr, OsString};
+    use std::ffi::{CStr, OsString, c_void};
     use std::io::Write;
     use std::os::unix::net::UnixStream;
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -16,6 +17,18 @@ mod _functiontrace_rs {
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Core Types
     ////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /// The configuration file for FunctionTrace.
+    ///
+    /// TODO: This is currently only used for licensing, but could reasonably be used to augment or
+    /// replace some of the env vars we use.
+    #[derive(Serialize, Deserialize, Clone, PartialEq)]
+    struct Config {
+        /// The user's license key.  This is NONCOMMERCIAL where relevant, and otherwise must
+        /// contain a key that will be validated on startup.
+        license_key: Option<String>,
+    }
+
     /// The size of messagepack buffers.  This is picked somewhat arbitrarily, but should be
     /// reasonably small since we'll need one per thread, and should be large enough that we
     /// can fit many messages in before needing to do expensive UnixStream syscalls.
@@ -72,7 +85,7 @@ mod _functiontrace_rs {
 
         /// Flush our local buffer to the socket.
         fn flush(&mut self) -> std::io::Result<()> {
-            // We're about to send all of the data, so reset our buffer.  Do this now to ensure we
+            // We're about to send all the data, so reset our buffer.  Do this now to ensure we
             // don't miss it, since the buffer will be left in an invalid state if this doesn't
             // happen.
             let head = self.head;
@@ -182,12 +195,40 @@ 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
+        // but get _something_ anyways.
+        // This may not be possible, but I suspect a different Rust extension could interfere with
+        // us so might as well be defensive.
+        if let Err(e) = tracing_subscriber::fmt::fmt()
+            .with_target(false)
+            .with_ansi(true)
+            .with_env_filter(tracing_subscriber::filter::EnvFilter::from_default_env())
+            .try_init()
+        {
+            tracing::error!(
+                error = e,
+                "Failed to install tracing_subscriber for FunctionTrace"
+            );
+        }
+
+        tracing::info!("Loaded `functiontrace` python module!");
+
         Ok(())
     }
 
@@ -213,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.
@@ -222,140 +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."
+                        );
+
+                        // 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")?,
+                };
 
-        // 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 = std::process::Command::new("functiontrace-server")
-                .arg("--directory")
-                .arg(output_directory)
-                .spawn()
-                .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();
 
-                    // We'll be cloning this
-                    full_args.shrink_to_fit();
-                    Ok(full_args)
+                    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| {
-                    // TODO: tracing log that this happened
+                    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();
+            let mut socket = message_initialize();
 
-                format!(
-                    "Python {}.{}.{}",
-                    version.major, version.minor, version.patch
-                )
-            });
+            init.serialize(&mut rmp_serde::encode::Serializer::new(&mut socket))
+                .wrap_err("Failed to emit TraceInitialization message")?;
 
-            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| {
-                // TODO: tracing log that this happened
-                "<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();
-
-        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
@@ -431,7 +488,7 @@ mod _functiontrace_rs {
     }
 
     /// Called when the process is shutting down via `atexit`, notifies us to stop tracing and
-    /// flush the buffer.  
+    /// flush the buffer.
     ///
     /// NOTE: This is always called on the main thread.
     fn trace_terminate(
@@ -596,7 +653,7 @@ mod _functiontrace_rs {
     }
 
     /// Enable memory tracing for the current program.  This is implemented by attaching wrapper
-    /// versions of malloc/free/etc to all of the current allocators.
+    /// versions of malloc/free/etc to all the current allocators.
     ///
     /// NOTE: Memory tracing may have up to 40% overhead on traces with many small allocations, so
     /// is not enabled by default.
@@ -825,7 +882,12 @@ mod _functiontrace_rs {
                                 if let Ok(module) = m_module.downcast::<pyo3::types::PyString>() {
                                     module.to_cow().unwrap_or(Cow::Borrowed("<invalid string>"))
                                 } else {
-                                    // TODO: tracing log this
+                                    if let Ok(typ) = m_module.get_type().qualname().map(|x| x.to_string()) {
+                                        tracing::warn!(type = typ, "Failed to read module name due to unexpected type");
+                                    } else {
+                                        tracing::warn!("Failed to read module name due to indecipherable type");
+                                    }
+
                                     Cow::Borrowed("<unknown module>")
                                 };
                             function_trace::FunctionTrace::NativeCall {
@@ -881,13 +943,452 @@ mod _functiontrace_rs {
                 // We unfortunately can't get these from `PyEval_SetProfile`, so we'd need to use a
                 // different method to capture them.
             }
-            _ => {
-                // TODO: this shouldn't be possible - tracing log it so we can handle later.
+            v => {
+                tracing::error!(event = v, "Unexpected PyTrace message!");
             }
         };
 
         0
     }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Commercial support
+    ////////////////////////////////////////////////////////////////////////////
+
+    /// Load our configuration, including:
+    /// - Displaying a first-use message
+    /// - Creating the configuration file if non-existent
+    /// - Validating license keys
+    ///
+    /// We default to being permissive, and want to make this as non-invasive as possible for
+    /// non-commercial users.
+    #[pyfunction]
+    fn load_config() -> Result<()> {
+        use owo_colors::OwoColorize;
+
+        ////////////////////////////////////////////////////////////////////////
+        // Load or initialize config file
+        ////////////////////////////////////////////////////////////////////////
+        // Load configuration from the standard directory, or `~/.config` if the XDG spec isn't
+        // being followed.
+        let config_path = {
+            if let Some(config_path) = std::env::var_os("FUNCTIONTRACE_CONFIGFILE") {
+                // Allow `FUNCTIONTRACE_CONFIGFILE` as an override (mostly for tests, but it could
+                // be useful for Nix users or others).
+                std::path::PathBuf::from(config_path)
+            } else if let Some(mut config_dir) = std::env::var_os("XDG_CONFIG_HOME")
+                .map(std::path::PathBuf::from)
+                .or_else(|| {
+                    std::env::home_dir().map(|mut home| {
+                        home.push(".config");
+                        home
+                    })
+                })
+            {
+                config_dir.push("functiontrace.toml");
+                config_dir
+            } else {
+                // If we fail to find a reasonable config path, we'll just pretend everything is
+                // fine.
+                tracing::error!(
+                    "Failed to find FunctionTrace config directory - proceeding without loading config"
+                );
+                return Ok(());
+            }
+        };
+
+        let config = if let Ok(config) = std::fs::read(&config_path)
+            .wrap_err("Failed to read config file")
+            .and_then(|x| toml::from_slice::<Config>(&x).wrap_err("Failed to parse config file"))
+        {
+            // We successfully loaded an existing config file.
+            config
+        } else {
+            // There's no config file, so assume this is the first time FunctionTrace has been
+            // used and generate a new one.
+            let logo = "\
+███████╗██╗   ██╗███╗   ██╗ ██████╗████████╗██╗ ██████╗ ███╗   ██╗████████╗██████╗  █████╗  ██████╗███████╗\n\
+██╔════╝██║   ██║████╗  ██║██╔════╝╚══██╔══╝██║██╔═══██╗████╗  ██║╚══██╔══╝██╔══██╗██╔══██╗██╔════╝██╔════╝\n\
+█████╗  ██║   ██║██╔██╗ ██║██║        ██║   ██║██║   ██║██╔██╗ ██║   ██║   ██████╔╝███████║██║     █████╗  \n\
+██╔══╝  ██║   ██║██║╚██╗██║██║        ██║   ██║██║   ██║██║╚██╗██║   ██║   ██╔══██╗██╔══██║██║     ██╔══╝  \n\
+██║     ╚██████╔╝██║ ╚████║╚██████╗   ██║   ██║╚██████╔╝██║ ╚████║   ██║   ██║  ██║██║  ██║╚██████╗███████╗\n\
+╚═╝      ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝   ╚═╝   ╚═╝ ╚═════╝ ╚═╝  ╚═══╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚══════╝\n";
+
+            // Render the logo like a flamechart using Python-esque colors.
+            for (row, line) in logo.lines().enumerate() {
+                for (x, c) in line.chars().enumerate() {
+                    // heights[x] represents the height of the flamechart at position x
+                    //
+                    // NOTE: These values were somewhat arbitrarily chosen, but the bottom row is
+                    // always covered.
+                    let heights = [
+                        1, 1, 3, 3, 4, 4, 4, 4, 3, 2, 2, 2, 2, 2, 3, 4, 5, 5, 3, 3, 1, 2, 2, 3, 4,
+                        4, 4, 4, 4, 4, 4, 3, 3, 3, 5, 5, 6, 6, 6, 5, 5, 3, 2, 2, 2, 3, 5, 5, 5, 5,
+                        5, 2, 2, 4, 6, 6, 6, 3, 2, 3, 3, 5, 3, 3, 5, 5, 5, 5, 3, 3, 2, 2, 1, 1, 1,
+                        1, 1, 2, 2, 2, 4, 4, 4, 3, 4, 3, 3, 3, 3, 2, 2, 5, 5, 5, 5, 5, 5, 4, 3, 2,
+                        2, 2, 2, 3, 4, 5, 5, 0,
+                    ];
+
+                    // We look at chart depth from top to bottom.
+                    let current_depth = 6 - row;
+
+                    if current_depth > heights[x] {
+                        print!("{}", c.blue());
+                    } else {
+                        print!("{}", c.fg::<owo_colors::colors::xterm::FlushOrange>());
+                    }
+                }
+                println!();
+            }
+            println!();
+            println!(
+                "{}",
+                "Welcome to FunctionTrace, a low overheard tracing profiler for Python".bold()
+            );
+            println!();
+            println!(
+                "Please see {} for instructions on setup and use.",
+                "https://functiontrace.com".underline().cyan()
+            );
+            println!(
+                "FunctionTrace will emit profile files ({}) that must be loaded by the",
+                "functiontrace.*.tar.gz".dimmed()
+            );
+            println!(
+                "Firefox Profiler ({}) for analysis.",
+                "https://profiler.firefox.com/".underline().cyan()
+            );
+            println!();
+
+            let config = Config { license_key: None };
+
+            match std::fs::write(
+                &config_path,
+                toml::to_string_pretty(&config).wrap_err("Failed to serialize config file")?,
+            ) {
+                Ok(_) => {
+                    println!(
+                        "{}{}",
+                        format_args!("Default config saved to {}", config_path.display().bold())
+                            .dimmed(),
+                        ".  This startup message will not be shown again.".dimmed()
+                    );
+                    println!();
+                }
+                Err(e) => {
+                    eprintln!(
+                        "Failed to create default FunctionTrace config file at {}: {e}",
+                        config_path.display().dimmed(),
+                    );
+                }
+            };
+
+            config
+        };
+
+        // We need to write out the config if it's changed.  Track the new and old configs so we
+        // can tell.
+        let mut new_config = config.clone();
+
+        ////////////////////////////////////////////////////////////////////////
+        // Find their license key
+        ////////////////////////////////////////////////////////////////////////
+        // Demo keys have the same general shape as a UUID, but include the expiration time
+        const DEMO_KEY_PREFIX: &str = "TRIALKEYX-";
+        const DEMO_KEY_FORMAT: &str = "%Y-%m%d-%H%M-%S%z";
+        const DEMO_KEY_SUFFIX: &str = "TRIAL";
+
+        let license_key = if let Some(license_key) = &config.license_key {
+            license_key.clone()
+        } else {
+            println!("FunctionTrace is open-source and may freely be used noncommercially under");
+            println!(
+                "the Prosperity Public License 3.0 ({}).",
+                "https://prosperitylicense.com/".underline().cyan()
+            );
+            println!();
+
+            /// Print a prompt, then read lines of input repeatedly until it successfully parses.
+            fn read_input<T, F>(prompt: std::fmt::Arguments, parser: F) -> Result<T>
+            where
+                F: Fn(&String) -> Option<T>,
+            {
+                let mut input = String::new();
+
+                loop {
+                    print!("{}", prompt);
+                    std::io::stdout().flush()?;
+
+                    input.clear();
+                    std::io::stdin().read_line(&mut input)?;
+
+                    if let Some(result) = parser(&input) {
+                        return Ok(result);
+                    }
+                    Python::with_gil(|py| {
+                        // We need to check with the Python interpreter during loops, otherwise we
+                        // might not receive ctrl-c events.
+                        py.check_signals()
+                    })?;
+                }
+            }
+
+            let commercial = read_input(
+                format_args!(
+                    "{} {}: ",
+                    "Are you using FunctionTrace commercially?".bold(),
+                    "[yes/no]".dimmed()
+                ),
+                |input| match input.chars().next() {
+                    Some('y') => Some(true),
+                    Some('n') => Some(false),
+                    _ => {
+                        eprintln!(
+                            "Failed to read {} or {} input.",
+                            "yes".dimmed(),
+                            "no".dimmed()
+                        );
+                        None
+                    }
+                },
+            )?;
+
+            let key = if !commercial {
+                "NONCOMMERCIAL".to_string()
+            } else {
+                println!();
+                println!(
+                    "The Prosperity Public License allows for a single 30 day trial period for commercial users."
+                );
+                let demo = read_input(
+                    format_args!(
+                        "{} {}: ",
+                        "Is this your company's first time using FunctionTrace?".bold(),
+                        "[yes/no]".dimmed()
+                    ),
+                    |input| match input.chars().next() {
+                        Some('y') => Some(true),
+                        Some('n') => Some(false),
+                        _ => {
+                            eprintln!(
+                                "Failed to read {} or {} input.",
+                                "yes".dimmed(),
+                                "no".dimmed()
+                            );
+                            None
+                        }
+                    },
+                )?;
+
+                if demo {
+                    // They haven't used FunctionTrace yet, so we'll generate them a demo key
+                    // that's valid for 30 days.
+                    let expiration = Timestamp::now()
+                        .checked_add(Duration::from_secs(3600 * 24 * 30))
+                        .expect("30 days in the future is valid");
+
+                    // Generate a key formatted like a UUID, but with the expiration time included
+                    format!(
+                        "{DEMO_KEY_PREFIX}{}{DEMO_KEY_SUFFIX}",
+                        expiration.strftime(DEMO_KEY_FORMAT)
+                    )
+                } else {
+                    println!();
+                    println!(
+                        "Commercial users must purchase an alternative license via {}.",
+                        "https://functiontrace.com".underline().cyan()
+                    );
+
+                    read_input(
+                        format_args!("{}: ", "Enter your FunctionTrace license key".bold()),
+                        |input| {
+                            if input.trim().chars().filter(|&c| c == '-').count() == 4 {
+                                // The key looks plausible.  We'll validate it later.
+                                Some(input.trim().to_string())
+                            } else {
+                                eprintln!(
+                                    "Invalid license format.  FunctionTrace license keys look like {}.",
+                                    "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX".dimmed()
+                                );
+                                None
+                            }
+                        },
+                    )?
+                }
+            };
+
+            new_config.license_key = Some(key.clone());
+            key
+        };
+
+        ////////////////////////////////////////////////////////////////////////
+        // Validate the license key
+        ////////////////////////////////////////////////////////////////////////
+        let valid_license = if license_key == "NONCOMMERCIAL" {
+            // The user has asserted that they're not using FunctionTrace for commercial
+            // purposes.  Nothing left to validate here.
+            true
+        } else if let Some(demo_key) = license_key
+            .strip_prefix(DEMO_KEY_PREFIX)
+            .and_then(|s| s.strip_suffix(DEMO_KEY_SUFFIX))
+        {
+            // The user has a demo key that's valid for 30 days from creation.
+            let now = Timestamp::now();
+
+            if let Ok(valid_expiration) = Timestamp::strptime(DEMO_KEY_FORMAT, demo_key) {
+                if now
+                    .until(valid_expiration)
+                    .map_or(false, |remaining| remaining.is_positive())
+                {
+                    // The license is still valid
+                    eprintln!(
+                        "{}: You're using a trial license that expires on {}.  Please visit {} to acquire a full license.",
+                        "FunctionTrace trial".yellow().bold(),
+                        valid_expiration.strftime("%Y-%m-%d").dimmed(),
+                        "https://functiontrace.com".underline().cyan(),
+                    );
+                    true
+                } else {
+                    eprintln!(
+                        "{}: You're using a trial license that expired on {}.  Please visit {} to acquire a full license.",
+                        "FunctionTrace trial expired".red().bold(),
+                        valid_expiration.strftime("%Y-%m-%d").dimmed(),
+                        "https://functiontrace.com".underline().cyan(),
+                    );
+                    false
+                }
+            } else {
+                // This demo key doesn't parse, so it's presumably invalid.
+                eprintln!(
+                    "{}: your company's trial has expired.  Please visit {} to acquire a license.",
+                    "FunctionTrace trial expired".red().bold().dimmed(),
+                    "https://functiontrace.com".underline().cyan(),
+                );
+                false
+            }
+        } else {
+            // The user has a commercial license key.  Validate it against our server
+            let client = reqwest::blocking::Client::new();
+            if let Ok(license_check) = client
+                .get("https://license.functiontrace.com")
+                .header("functiontrace-key", &license_key)
+                .timeout(
+                    // We set a short timeout, since the license server should respond within a few
+                    // ms and we don't want to block users if it can't be contacted.
+                    Duration::from_secs(2),
+                )
+                .send()
+            {
+                /// Represents useful information about a given license
+                #[derive(Deserialize)]
+                struct LicenseInfo {
+                    #[serde(rename = "Seats")]
+                    seats: u32,
+                    #[serde(rename = "Expires")]
+                    expires: Timestamp,
+                }
+
+                match license_check.status() {
+                    reqwest::StatusCode::OK => {
+                        // This key is live!
+                        if let Ok(info) = license_check.json::<LicenseInfo>() {
+                            tracing::info!(
+                                seats = info.seats,
+                                expiration = info.expires.strftime("%F").to_string(),
+                                "Valid license loaded"
+                            );
+                        } else {
+                            tracing::info!(
+                                seats = "unknown",
+                                expiration = "unknown",
+                                "Valid license loaded"
+                            );
+                        }
+                    }
+                    reqwest::StatusCode::BAD_REQUEST => {
+                        // This license does not and has never existed.
+                        eprintln!(
+                            "{}: {} is not a valid FunctionTrace license.",
+                            "Invalid Functiontrace license".red().bold(),
+                            license_key.dimmed()
+                        );
+
+                        // Mark this license key for deletion.  We don't need to inform the user,
+                        // since it never could have worked.
+                        new_config.license_key = None;
+                    }
+                    reqwest::StatusCode::PAYMENT_REQUIRED => {
+                        // This license used to be valid but isn't anymore.
+                        if let Ok(info) = license_check.json::<LicenseInfo>() {
+                            eprintln!(
+                                "{}: {} expired on {}.  Please visit {} to acquire a new license.",
+                                "FunctionTrace license expired".red().bold(),
+                                license_key.dimmed(),
+                                info.expires.strftime("%F").bold(),
+                                "https://functiontrace.com".underline().cyan(),
+                            );
+                        } else {
+                            eprintln!(
+                                "{}: {} has expired.  Please visit {} to acquire a new license.",
+                                "FunctionTrace license expired".red().bold(),
+                                license_key.dimmed(),
+                                "https://functiontrace.com".underline().cyan(),
+                            );
+                        }
+
+                        eprintln!(
+                            "Removing expired FunctionTrace license key from {}.",
+                            config_path.display().dimmed()
+                        );
+                        new_config.license_key = None;
+                    }
+                    reqwest::StatusCode::INTERNAL_SERVER_ERROR => {
+                        // The license server crashed?
+                        tracing::warn!(
+                            "License server returned an error - assuming license is valid"
+                        );
+                    }
+                    status => {
+                        tracing::warn!(
+                            code = status.as_u16(),
+                            "License server returned an unexpected code - assuming license is valid"
+                        );
+                    }
+                };
+
+                // If there's still a license key stored in the config file, we must've validated
+                // it.
+                new_config.license_key.is_some()
+            } else {
+                // We didn't successfully talk to the license server.  Assume everything is fine.
+                true
+            }
+        };
+
+        ////////////////////////////////////////////////////////////////////////
+        // Save the updated config
+        ////////////////////////////////////////////////////////////////////////
+        if new_config != config {
+            // We updated the configuration file, so save it out.
+            if let Err(e) = std::fs::write(
+                &config_path,
+                toml::to_string_pretty(&new_config).wrap_err("Failed to serialize config file")?,
+            ) {
+                eprintln!(
+                    "Failed to update FunctionTrace config file at {}: {e}",
+                    config_path.display().dimmed(),
+                );
+            };
+        }
+
+        if !valid_license {
+            // We've already printed information about what's happening, so it's safe to just kill
+            // the process.
+            std::process::exit(1);
+        }
+
+        Ok(())
+    }
 }
 
 /// Allocation hooks and helpers for tracing Python memory allocator operations.
@@ -997,7 +1498,7 @@ mod hooks {
     use color_eyre::eyre::{Result, WrapErr};
     use functiontrace_server::function_trace;
     use pyo3::ffi::PyObject;
-    use pyo3::prelude::*; // TODO: What's in here?
+    use pyo3::prelude::*;
     use serde::Serialize;
     use std::borrow::Cow;
     use std::sync::OnceLock;
@@ -1148,7 +1649,7 @@ mod hooks {
             .get()
             .expect("Wrapper functions can't be called until hooked");
 
-        Python::with_gil(|py| -> Result<()> {
+        let proxied = Python::with_gil(|py| -> Result<()> {
             if let Some(mut writer) = crate::_functiontrace_rs::thread_state() {
                 let args = unsafe {
                     // SAFETY: `args` represents a valid argument tuple
@@ -1167,10 +1668,15 @@ mod hooks {
 
             Ok(())
         })
-        .wrap_err_with(|| format!("FunctionTrace proxy logging for {} failed", hook.target))
-        // TODO: This shouldn't be catastrophic - we can log it and continue on
-        // instead once we introduce `tracing`.
-        .expect("Proxying should never fail");
+        .wrap_err_with(|| format!("FunctionTrace proxy logging for {} failed", hook.target));
+
+        if let Err(e) = proxied {
+            tracing::error!(
+                error = e.to_string(),
+                function = hook.target,
+                "Failed to properly handle hooked function"
+            );
+        }
 
         unsafe {
             // SAFETY: This is a direct translation of the original call we're proxying