functiontrace 0.4.4__tar.gz → 0.5.0__tar.gz

{functiontrace-0.4.4 → functiontrace-0.5.0}/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.0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functiontrace
-Version: 0.4.4
+Version: 0.5.0
 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.0}/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")
@@ -79,6 +65,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.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "functiontrace"
-version = "0.4.4"
+version = "0.5.0"
 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.0}/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;
@@ -188,6 +201,24 @@ mod _functiontrace_rs {
 
         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(())
     }
 
@@ -228,11 +259,24 @@ mod _functiontrace_rs {
         // 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")
+            let server = match std::process::Command::new("functiontrace-server")
                 .arg("--directory")
                 .arg(output_directory)
                 .spawn()
-                .wrap_err("Failed to launch functiontrace-server")?;
+            {
+                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")?,
+            };
 
             format!("/tmp/functiontrace-server.sock.{}", server.id()).into()
         };
@@ -299,7 +343,8 @@ mod _functiontrace_rs {
                     Ok(full_args)
                 })
                 .unwrap_or_else(|_err| {
-                    // TODO: tracing log that this happened
+                    tracing::warn!("Failed to read ARGV");
+
                     "<UNKNOWN>".into()
                 });
 
@@ -333,7 +378,8 @@ mod _functiontrace_rs {
                     .into())
             })
             .unwrap_or_else(|_err| {
-                // TODO: tracing log that this happened
+                tracing::warn!("Failed to read sys.platform");
+
                 "<UNKNOWN>".into()
             });
 
@@ -431,7 +477,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 +642,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 +871,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 +932,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 +1487,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 +1638,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 +1657,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