Fix estrdup crash by calling sapi.startup() inside spawn_blocking

The crash in CI occurred because estrdup was being called before PHP's
memory allocator was properly initialized on the worker thread. The root
cause was identified through debug logging that showed the crash happened
at the first estrdup call after ThreadScope::new().

The fix adds a sapi.startup() call inside spawn_blocking, after
ThreadScope::new() but before any estrdup calls. This mirrors the main
branch behavior where self.sapi.startup() was called in every handle()
before estrdup operations.

Key changes:
- Added Sapi::startup() method that calls the SAPI module startup function
- Call sapi.startup() inside spawn_blocking to initialize PHP's memory
  allocator on the worker thread
- Removed debug logging that was added to diagnose the crash

The SAPI startup (php_module_startup) sets up per-thread state needed
for emalloc/estrdup to work. Without it, ts_resource(0) alone doesn't
fully initialize the memory allocator on ZTS builds.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: Qard

src/embed.rs

@@ -341,67 +341,47 @@ impl Handler for Embed {
 
     // Spawn blocking PHP execution - ALL PHP operations happen here
     let blocking_handle = tokio::task::spawn_blocking(move || {
-      eprintln!("[DEBUG] spawn_blocking: starting");
       // Keep sapi alive for the duration of this task
-      let _sapi = _sapi;
-      eprintln!("[DEBUG] spawn_blocking: creating ThreadScope");
+      let sapi = _sapi;
+      // Initialize thread-local storage for this worker thread
       let _thread_scope = ThreadScope::new();
-      eprintln!("[DEBUG] spawn_blocking: ThreadScope created");
+      // Call SAPI startup on THIS thread to initialize PHP's memory allocator.
+      // This is required before any estrdup calls can be made.
+      // php_module_startup() sets up per-thread state needed for emalloc/estrdup.
+      sapi.startup().map_err(|_| EmbedRequestError::SapiNotStarted)?;
+      // Keep sapi alive for the duration of this task
+      let _sapi = sapi;
 
       // Setup RequestContext (always streaming from SAPI perspective)
       // RequestContext::new() will extract the request body's read stream and add it as RequestStream extension
-      eprintln!("[DEBUG] spawn_blocking: creating RequestContext");
       let ctx = RequestContext::new(
         request,
         docroot.clone(),
         response_writer.clone(),
         headers_sent_tx,
       );
-      eprintln!("[DEBUG] spawn_blocking: setting RequestContext::current");
       RequestContext::set_current(Box::new(ctx));
-      eprintln!("[DEBUG] spawn_blocking: RequestContext set");
 
-      // All estrdup calls MUST happen here, inside spawn_blocking, after ThreadScope::new()
-      // has initialized PHP's memory manager for this thread.
-      // These will be freed by efree in sapi_module_deactivate during request shutdown.
-      eprintln!("[DEBUG] estrdup 1/5: request_uri_str - BEFORE");
+      // All estrdup calls happen here, inside spawn_blocking, after ThreadScope::new()
+      // has initialized PHP's thread-local storage. These will be freed by efree in
+      // sapi_module_deactivate during request shutdown.
       let request_uri_c = estrdup(request_uri_str.as_str());
-      eprintln!("[DEBUG] estrdup 1/5: request_uri_str - AFTER (ptr={:?})", request_uri_c);
-
-      eprintln!("[DEBUG] estrdup 2/5: path_translated - BEFORE");
       let path_translated = estrdup(translated_path_str.as_str());
-      eprintln!("[DEBUG] estrdup 2/5: path_translated - AFTER (ptr={:?})", path_translated);
-
-      eprintln!("[DEBUG] estrdup 3/5: request_method - BEFORE");
       let request_method = estrdup(method_str.as_str());
-      eprintln!("[DEBUG] estrdup 3/5: request_method - AFTER (ptr={:?})", request_method);
-
-      eprintln!("[DEBUG] estrdup 4/5: query_string - BEFORE");
       let query_string = estrdup(query_str.as_str());
-      eprintln!("[DEBUG] estrdup 4/5: query_string - AFTER (ptr={:?})", query_string);
-
-      eprintln!("[DEBUG] estrdup 5/5: content_type - BEFORE");
       let content_type = content_type_str
         .as_ref()
-        .map(|s| {
-          eprintln!("[DEBUG] estrdup 5/5: content_type has value, calling estrdup");
-          estrdup(s.as_str())
-        })
+        .map(|s| estrdup(s.as_str()))
         .unwrap_or(std::ptr::null_mut());
-      eprintln!("[DEBUG] estrdup 5/5: content_type - AFTER (ptr={:?})", content_type);
 
       // Prepare argv pointers
       let argc = args.len() as i32;
-      eprintln!("[DEBUG] estrdup argv: {} args to process - BEFORE", argc);
-      let mut argv_ptrs: Vec<*mut c_char> = args.iter().enumerate().map(|(i, s)| {
-        eprintln!("[DEBUG] estrdup argv[{}] - BEFORE", i);
-        let ptr = estrdup(s.as_str());
-        eprintln!("[DEBUG] estrdup argv[{}] - AFTER (ptr={:?})", i, ptr);
-        ptr
-      }).collect();
-      eprintln!("[DEBUG] estrdup argv complete");
-
-      // Set SAPI globals
+      let mut argv_ptrs: Vec<*mut c_char> = args
+        .iter()
+        .map(|s| estrdup(s.as_str()))
+        .collect();
+
+      // Set SAPI globals BEFORE php_request_startup since PHP reads these during initialization
       {
         let mut globals = SapiGlobals::get_mut();
         globals.options |= ext_php_rs::ffi::SAPI_OPTION_NO_CHDIR as i32;

src/sapi.rs

@@ -114,6 +114,24 @@ impl Sapi {
     })
   }
 
+  /// Initialize PHP for the current thread and call the SAPI module startup.
+  /// This must be called on each worker thread before using PHP's memory allocator (estrdup).
+  /// On ZTS builds, this initializes thread-local storage and module state.
+  pub fn startup(&self) -> Result<(), EmbedRequestError> {
+    let sapi = &mut self
+      .module
+      .write()
+      .map_err(|_| EmbedRequestError::SapiNotStarted)?;
+
+    if let Some(startup) = sapi.startup {
+      if unsafe { startup(sapi.as_mut()) } != ZEND_RESULT_CODE_SUCCESS {
+        return Err(EmbedRequestError::SapiNotStarted);
+      }
+    }
+
+    Ok(())
+  }
+
   pub fn shutdown(&self) -> Result<(), EmbedRequestError> {
     // Only shutdown if we're on the same thread that created this Sapi
     let current_thread = std::thread::current().id();

src/scopes.rs

@@ -20,24 +20,18 @@ pub(crate) struct ThreadScope();
 
 impl ThreadScope {
   pub fn new() -> Self {
-    let thread_id = std::thread::current().id();
-    eprintln!("[DEBUG] ThreadScope::new() on thread {:?} - calling ext_php_rs_sapi_per_thread_init", thread_id);
     unsafe {
       ext_php_rs_sapi_per_thread_init();
     }
-    eprintln!("[DEBUG] ThreadScope::new() on thread {:?} - ext_php_rs_sapi_per_thread_init complete", thread_id);
     Self()
   }
 }
 
 impl Drop for ThreadScope {
   fn drop(&mut self) {
-    let thread_id = std::thread::current().id();
-    eprintln!("[DEBUG] ThreadScope::drop() on thread {:?} - calling ext_php_rs_sapi_per_thread_shutdown", thread_id);
     unsafe {
       ext_php_rs_sapi_per_thread_shutdown();
     }
-    eprintln!("[DEBUG] ThreadScope::drop() on thread {:?} - ext_php_rs_sapi_per_thread_shutdown complete", thread_id);
   }
 }
 
@@ -73,7 +67,6 @@ impl FileHandleScope {
     P: AsRef<Path>,
   {
     let path_str = path.as_ref().to_str().unwrap();
-    eprintln!("[DEBUG] FileHandleScope::new - estrdup for path '{}' - BEFORE", path_str);
     let mut handle = zend_file_handle {
       handle: _zend_file_handle__bindgen_ty_1 {
         fp: std::ptr::null_mut(),
@@ -88,7 +81,6 @@ impl FileHandleScope {
     };
 
     let path = estrdup(path_str);
-    eprintln!("[DEBUG] FileHandleScope::new - estrdup for path - AFTER (ptr={:?})", path);
 
     unsafe {
       zend_stream_init_filename(&mut handle, path);