itsi 0.2.21.rc1 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de46fbc801d723fe981489c7170e18d344b7f0de59b340c1c053bd89d880e3be
-  data.tar.gz: 3b07a649c4de609d4e022962e7745788bebda8a07819bf930dbefea8f5fdebd4
+  metadata.gz: edac434aa9724351fa9fe5220e3451534473303c08d5b6ad34d56bbd5fb1aec6
+  data.tar.gz: 88efe1b953ed1a418666d32730450eb7c14c232d25ea94dcc4b1f169f649367e
 SHA512:
-  metadata.gz: daee3821c95ff7a9de766eca58fb92a207ee26f9d6f7526da73159474e5b598ba6ccd5776b432736cb67ab79a9d394853f180cd09796d9874cd9491cfd5c34cc
-  data.tar.gz: 3c744080b6f29042b572aedb37c0d7c5a6ed30eb83e9a93db2646d802637a50380c335f9bd30be3c3a48ade597c2bc1cdf26d171d36ee5eed590f02a7dc762a7
+  metadata.gz: 675fe7f09ec66c9583f3c69963127f3ec01e46bf613657bc7d8778919dfccf2a38d420348af3ed51fd5f4df6d05291fec816eab78daa67325196d589eb7dae82
+  data.tar.gz: e6d3276f2b3e59f5dd6cda1f3bcb44e54a59260ca0bf265092bd26069f6ecb3a2c56ad804792a2304062f3e6f3e0e355cf668b89a9a8a93a18168ca4f90ed811

data/.dockerignore

@@ -0,0 +1,3 @@
+target
+gems/scheduler/target
+gems/server/target

data/.rubocop.yml

@@ -0,0 +1,20 @@
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
+  Include:
+    - gems/server/lib/**/*.rb
+    - gems/scheduler/lib/**/*.rb
+  Exclude:
+    - examples/**/*
+    - gems/**/tmp/**/*
+    - target/**/*
+    - pkg/**/*
+    - vendor/**/*
+    - tmp/**/*
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## [0.2.21] - 2026-02-16
+- Fix Ruby 2.7 startup NameError in static_assets redirect schema load path
+
 ## [0.2.21-rc1] - 2026-01-08
 - Removed Rust `target-cpu=native` to avoid illegal instruction on older CPUs.
 

data/Cargo.lock

@@ -1644,7 +1644,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-scheduler"
-version = "0.2.20"
+version = "0.2.21"
 dependencies = [
  "bytes",
  "derive_more",
@@ -1662,7 +1662,7 @@ dependencies = [
 
 [[package]]
 name = "itsi-server"
-version = "0.2.20"
+version = "0.2.21"
 dependencies = [
  "argon2",
  "async-channel",
@@ -1933,9 +1933,9 @@ checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "magnus"
-version = "0.7.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d87ae53030f3a22e83879e666cb94e58a7bdf31706878a0ba48752994146dab"
+checksum = "3b36a5b126bbe97eb0d02d07acfeb327036c6319fd816139a49824a83b7f9012"
 dependencies = [
  "bytes",
  "magnus-macros",
@@ -1946,9 +1946,9 @@ dependencies = [
 
 [[package]]
 name = "magnus-macros"
-version = "0.6.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5968c820e2960565f647819f5928a42d6e874551cab9d88d75e3e0660d7f71e3"
+checksum = "47607461fd8e1513cb4f2076c197d8092d921a1ea75bd08af97398f593751892"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2581,18 +2581,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.111"
+version = "0.9.124"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "becea799ce051c16fb140be80f5e7cf781070f99ca099332383c2b17861249af"
+checksum = "c85c4188462601e2aa1469def389c17228566f82ea72f137ed096f21591bc489"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.111"
+version = "0.9.124"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64691175abc704862f60a9ca8ef06174080cc50615f2bf1d4759f46db18b4d29"
+checksum = "568068db4102230882e6d4ae8de6632e224ca75fe5970f6e026a04e91ed635d3"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -2605,9 +2605,9 @@ dependencies = [
 
 [[package]]
 name = "rb-sys-env"
-version = "0.1.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
+checksum = "cca7ad6a7e21e72151d56fe2495a259b5670e204c3adac41ee7ef676ea08117a"
 
 [[package]]
 name = "rcgen"
@@ -2999,9 +2999,9 @@ dependencies = [
 
 [[package]]
 name = "serde_magnus"
-version = "0.9.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b8b945a2dadb221f1c5490cfb411cab6c3821446b8eca50ee07e5a3893ec51"
+checksum = "8ff64c88ddd26acdcad5a501f18bcc339927b77b69f4a03bfaf2a6fc5ba2ac4b"
 dependencies = [
  "magnus",
  "serde",

data/Dockerfile

@@ -0,0 +1,9 @@
+FROM ruby:3.4
+
+RUN apt-get update && apt-get install build-essential libclang-dev -y && apt-get clean && rm -rf /var/lib/apt/lists/*
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
+
+COPY pkg/itsi-server-0.2.21.gem .
+RUN gem install itsi-server-0.2.21.gem
+
+CMD ["itsi", "serve"]

data/crates/itsi_acme/src/caches/no.rs

@@ -7,7 +7,7 @@ use std::sync::atomic::AtomicPtr;
 
 /// No-op cache, which does nothing.
 /// ```rust
-/// # use tokio_rustls_acme::caches::NoCache;
+/// # use itsi_acme::caches::NoCache;
 /// # type EC = std::io::Error;
 /// # type EA = EC;
 /// let no_cache = NoCache::<EC, EA>::new();

data/crates/itsi_acme/src/caches/test.rs

@@ -10,9 +10,9 @@ use std::sync::atomic::AtomicPtr;
 use std::sync::Arc;
 
 /// Test cache, which generates certificates for ACME incompatible test environments.
-/// ```rust
-/// # use tokio_rustls_acme::{AcmeConfig};
-/// # use tokio_rustls_acme::caches::{DirCache, TestCache};
+/// ```rust,no_run
+/// # use itsi_acme::AcmeConfig;
+/// # use itsi_acme::caches::{DirCache, TestCache};
 /// # let test_environment = true;
 /// let mut config = AcmeConfig::new(["example.com"])
 ///     .cache(DirCache::new("./cache"));

data/crates/itsi_acme/src/config.rs

@@ -31,9 +31,9 @@ impl AcmeConfig<Infallible, Infallible> {
     /// error types will be `Infallible` since the cache cannot return an error. The methods to set
     /// a cache will change the error types to match those returned by the supplied cache.
     ///
-    /// ```rust
-    /// # use tokio_rustls_acme::AcmeConfig;
-    /// use tokio_rustls_acme::caches::DirCache;
+    /// ```rust,no_run
+    /// # use itsi_acme::AcmeConfig;
+    /// use itsi_acme::caches::DirCache;
     /// let config = AcmeConfig::new(["example.com"]).cache(DirCache::new("./rustls_acme_cache"));
     /// ```
     ///
@@ -43,9 +43,9 @@ impl AcmeConfig<Infallible, Infallible> {
     /// An uncached instance of [AcmeConfig] with particular type parameters can be created using
     /// [NoCache].
     ///
-    /// ```rust
-    /// # use tokio_rustls_acme::AcmeConfig;
-    /// use tokio_rustls_acme::caches::NoCache;
+    /// ```rust,no_run
+    /// # use itsi_acme::AcmeConfig;
+    /// use itsi_acme::caches::NoCache;
     /// # type EC = std::io::Error;
     /// # type EA = EC;
     /// let config: AcmeConfig<EC, EA> = AcmeConfig::new(["example.com"]).cache(NoCache::new());

data/crates/itsi_acme/src/lib.rs

@@ -31,7 +31,7 @@
 //! ```rust,no_run
 //! use tokio::io::AsyncWriteExt;
 //! use futures::StreamExt;
-//! use tokio_rustls_acme::{AcmeConfig, caches::DirCache};
+//! use itsi_acme::{AcmeConfig, caches::DirCache};
 //! use tokio_stream::wrappers::TcpListenerStream;
 //!
 //! #[tokio::main]

data/crates/itsi_error/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 thiserror = "2.0.11"
-magnus = { version = "0.7.1" }
+magnus = { version = "0.8.2" }
 rcgen = "0.13.2"
 nix = "0.29.0"
 httparse = "1.10.1"

data/crates/itsi_error/src/lib.rs

@@ -1,9 +1,6 @@
 pub use anyhow::Context;
 use magnus::Error as MagnusError;
-use magnus::{
-    error::ErrorType,
-    exception::{self, arg_error, standard_error},
-};
+use magnus::{error::ErrorType, Ruby};
 use thiserror::Error;
 
 pub static CLIENT_CONNECTION_CLOSED: &str = "Client disconnected";
@@ -73,7 +70,10 @@ pub trait IntoMagnusError {
 
 impl<T: std::error::Error> IntoMagnusError for T {
     fn into_magnus_error(self) -> MagnusError {
-        MagnusError::new(standard_error(), self.to_string())
+        MagnusError::new(
+            Ruby::get().unwrap().exception_standard_error(),
+            self.to_string(),
+        )
     }
 }
 
@@ -92,17 +92,34 @@ impl From<String> for ItsiError {
 impl From<ItsiError> for magnus::Error {
     fn from(err: ItsiError) -> Self {
         match err {
-            ItsiError::InvalidInput(msg) => magnus::Error::new(arg_error(), msg),
-            ItsiError::InternalServerError(msg) => magnus::Error::new(standard_error(), msg),
-            ItsiError::InternalError(msg) => magnus::Error::new(standard_error(), msg),
-            ItsiError::UnsupportedProtocol(msg) => magnus::Error::new(arg_error(), msg),
-            ItsiError::ArgumentError(msg) => magnus::Error::new(arg_error(), msg),
-            ItsiError::Jump(msg) => magnus::Error::new(exception::local_jump_error(), msg),
-            ItsiError::ClientConnectionClosed => {
-                magnus::Error::new(exception::eof_error(), CLIENT_CONNECTION_CLOSED)
+            ItsiError::InvalidInput(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_arg_error(), msg)
+            }
+            ItsiError::InternalServerError(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_standard_error(), msg)
+            }
+            ItsiError::InternalError(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_standard_error(), msg)
+            }
+            ItsiError::UnsupportedProtocol(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_arg_error(), msg)
+            }
+            ItsiError::ArgumentError(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_arg_error(), msg)
+            }
+            ItsiError::Jump(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_local_jump_error(), msg)
+            }
+            ItsiError::ClientConnectionClosed => magnus::Error::new(
+                Ruby::get().unwrap().exception_eof_error(),
+                CLIENT_CONNECTION_CLOSED,
+            ),
+            ItsiError::Break => {
+                magnus::Error::new(Ruby::get().unwrap().exception_interrupt(), "Break")
+            }
+            ItsiError::Pass => {
+                magnus::Error::new(Ruby::get().unwrap().exception_interrupt(), "Pass")
             }
-            ItsiError::Break => magnus::Error::new(exception::interrupt(), "Break"),
-            ItsiError::Pass => magnus::Error::new(exception::interrupt(), "Pass"),
             ItsiError::Io(err) => err.into_magnus_error(),
             ItsiError::Rcgen(err) => err.into_magnus_error(),
             ItsiError::HttpParse(err) => err.into_magnus_error(),

data/crates/itsi_rb_helpers/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 cfg-if = "1.0.0"
-magnus = { version = "0.7.1", features = ["rb-sys", "bytes"] }
+magnus = { version = "0.8.2", features = ["rb-sys", "bytes"] }
 nix = "0.29.0"
-rb-sys = "0.9.105"
+rb-sys = "0.9.117"
 serde = "1.0.219"

data/crates/itsi_rb_helpers/src/heap_value.rs

@@ -1,7 +1,7 @@
-use magnus::IntoValue;
 use magnus::rb_sys::AsRawValue;
 use magnus::value::BoxValue;
-use magnus::{Ruby, Value, value::ReprValue};
+use magnus::IntoValue;
+use magnus::{value::ReprValue, Ruby, Value};
 use std::fmt::{self, Debug, Formatter};
 use std::ops::Deref;
 
@@ -66,7 +66,7 @@ where
     T: ReprValue,
 {
     fn into_value_with(self, _: &Ruby) -> Value {
-        self.0.into_value()
+        self.0.into_value_with(&magnus::Ruby::get().unwrap())
     }
 }
 
@@ -116,7 +116,7 @@ impl Deref for HeapVal {
 
 impl IntoValue for HeapVal {
     fn into_value_with(self, _: &Ruby) -> Value {
-        self.0.into_value()
+        self.0.into_value_with(&magnus::Ruby::get().unwrap())
     }
 }
 

data/crates/itsi_rb_helpers/src/lib.rs

@@ -1,14 +1,14 @@
 use std::{ffi::c_int, os::raw::c_void, ptr::null_mut};
 
 use magnus::{
-    ArgList, RArray, Ruby, Thread, Value,
     block::Proc,
-    rb_sys::{AsRawId, FromRawValue, protect},
+    rb_sys::{protect, AsRawId, FromRawValue},
     value::{IntoId, LazyId, ReprValue},
+    ArgList, RArray, Ruby, Thread, Value,
 };
 use rb_sys::{
-    VALUE, rb_funcallv, rb_thread_call_with_gvl, rb_thread_call_without_gvl, rb_thread_create,
-    rb_thread_schedule, rb_thread_wakeup,
+    rb_funcallv, rb_thread_call_with_gvl, rb_thread_call_without_gvl, rb_thread_create,
+    rb_thread_schedule, rb_thread_wakeup, VALUE,
 };
 
 mod heap_value;
@@ -182,7 +182,11 @@ pub fn terminate_non_fork_safe_threads() {
                 && !v_thread
                     .funcall::<_, _, bool>(*ID_THREAD_VARIABLE_GET, (ruby.sym_new("fork_safe"),))
                     .unwrap_or(false);
-            if non_fork_safe { Some(v_thread) } else { None }
+            if non_fork_safe {
+                Some(v_thread)
+            } else {
+                None
+            }
         })
         .collect::<Vec<_>>();
 

data/crates/itsi_scheduler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-scheduler"
-version = "0.2.21-rc1"
+version = "0.2.21"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"
@@ -10,7 +10,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.7.1", features = ["rb-sys", "bytes"] }
+magnus = { version = "0.8.2", features = ["rb-sys", "bytes"] }
 derive_more = { version = "2.0.1", features = ["debug"] }
 itsi_tracing = { path = "../itsi_tracing" }
 itsi_rb_helpers = { path = "../itsi_rb_helpers" }
@@ -18,7 +18,7 @@ itsi_error = { path = "../itsi_error" }
 itsi_instrument_entry = { path = "../itsi_instrument_entry" }
 parking_lot = "0.12.3"
 mio = { version = "1.0.3", features = ["os-poll", "os-ext"] }
-rb-sys = "0.9.105"
+rb-sys = "0.9.117"
 bytes = "1.10.1"
 nix = "0.29.0"
 tracing = "0.1.41"

data/crates/itsi_scheduler/src/itsi_scheduler.rs

@@ -68,7 +68,7 @@ impl ItsiScheduler {
     pub fn wake(&self) -> MagnusResult<()> {
         self.waker.lock().wake().map_err(|_| {
             magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 "Failed to wake the scheduler",
             )
         })?;

data/crates/itsi_server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-server"
-version = "0.2.21-rc1"
+version = "0.2.21"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"
@@ -42,7 +42,7 @@ itsi_rb_helpers = { path = "../itsi_rb_helpers" }
 itsi_tracing = { path = "../itsi_tracing" }
 itsi_acme = { path = "../itsi_acme" }
 jsonwebtoken = "9.3.1"
-magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
+magnus = { version = "0.8.2", features = ["bytes", "rb-sys"] }
 notify = { version = "8.0.0" }
 nix = { version = "0.29.0", features = [
   "socket",
@@ -72,7 +72,7 @@ rustls = "0.23.23"
 rustls-pemfile = "2.2.0"
 serde = "1.0.219"
 serde_json = "1.0.140"
-serde_magnus = "0.9.0"
+serde_magnus = "0.11.0"
 sha2 = "0.10.8"
 socket2 = "0.5.8"
 sysinfo = "0.33.1"

data/crates/itsi_server/src/lib.rs

@@ -7,7 +7,7 @@ pub mod ruby_types;
 pub mod server;
 pub mod services;
 
-use magnus::{error::Result, function, method, Module, Object, Ruby};
+use magnus::{error::Result, function, method, Class, Module, Object, Ruby};
 use prelude::*;
 use ruby_types::{
     itsi_body_proxy::ItsiBodyProxy, itsi_grpc_call::ItsiGrpcCall,
@@ -36,7 +36,8 @@ fn init(ruby: &Ruby) -> Result<()> {
     )?;
 
     let server = ruby.get_inner(&ITSI_SERVER);
-    server.define_singleton_method("new", function!(ItsiServer::new, 3))?;
+    server.define_alloc_func::<ItsiServer>();
+    server.define_method("initialize", method!(ItsiServer::initialize, 3))?;
     server.define_singleton_method("reset_signal_handlers", function!(reset_signal_handlers, 0))?;
     server.define_method("start", method!(ItsiServer::start, 0))?;
     server.define_method("stop", method!(ItsiServer::stop, 0))?;

data/crates/itsi_server/src/ruby_types/itsi_body_proxy/big_bytes.rs

@@ -50,14 +50,21 @@ impl BigBytes {
                 if bytes.is_empty() {
                     None
                 } else {
-                    Some(bytes.into_value())
+                    Some(bytes.into_value_with(&magnus::Ruby::get().unwrap()))
                 }
             }
             BigBytes::OnDisk(path) => {
                 let ruby = Ruby::get().unwrap();
                 let rarray = ruby.ary_new();
-                rarray.push(path.path().to_str().unwrap().into_value()).ok();
-                Some(rarray.into_value())
+                rarray
+                    .push(
+                        path.path()
+                            .to_str()
+                            .unwrap()
+                            .into_value_with(&magnus::Ruby::get().unwrap()),
+                    )
+                    .ok();
+                Some(rarray.into_value_with(&magnus::Ruby::get().unwrap()))
             }
         }
     }

data/crates/itsi_server/src/ruby_types/itsi_body_proxy/mod.rs

@@ -32,7 +32,9 @@ impl ItsiBody {
     pub fn into_value(&self) -> Option<Value> {
         match self {
             ItsiBody::Buffered(bytes) => bytes.as_value(),
-            ItsiBody::Stream(proxy) => Some(proxy.clone().into_value()),
+            ItsiBody::Stream(proxy) => {
+                Some(proxy.clone().into_value_with(&magnus::Ruby::get().unwrap()))
+            }
             ItsiBody::Empty => None,
         }
     }
@@ -54,7 +56,7 @@ impl ItsiBodyProxy {
             if let Some(chunk) = block_on(stream.next()) {
                 let chunk = chunk.map_err(|err| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Error reading body {:?}", err),
                     )
                 })?;
@@ -86,7 +88,7 @@ impl ItsiBodyProxy {
             if let Some(chunk) = block_on(stream.next()) {
                 let chunk = chunk.map_err(|err| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Error reading body {:?}", err),
                     )
                 })?;
@@ -97,7 +99,9 @@ impl ItsiBodyProxy {
                 break;
             }
         }
-        let output_string = buffer.take().unwrap_or(RString::buf_new(buf.len()));
+        let output_string = buffer
+            .take()
+            .unwrap_or(magnus::Ruby::get().unwrap().str_buf_new(buf.len()));
         output_string.cat(buf.clone());
         buf.clear();
         Ok(Some(output_string))
@@ -111,7 +115,7 @@ impl ItsiBodyProxy {
         while let Some(chunk) = block_on(stream.next()) {
             let chunk = chunk.map_err(|err| {
                 magnus::Error::new(
-                    magnus::exception::standard_error(),
+                    magnus::Ruby::get().unwrap().exception_standard_error(),
                     format!("Error reading body {:?}", err),
                 )
             })?;
@@ -133,7 +137,7 @@ impl ItsiBodyProxy {
     fn verify_open(&self) -> MagnusResult<()> {
         if self.closed.load(atomic::Ordering::SeqCst) {
             return Err(magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 "Body stream is closed",
             ));
         }

data/crates/itsi_server/src/ruby_types/itsi_grpc_call.rs

@@ -64,7 +64,9 @@ impl ItsiGrpcCall {
         let snake_case_method_name = METHOD_NAME_REGEX
             .replace_all(method_name, "${1}_${2}")
             .to_lowercase();
-        Ok(Symbol::new(snake_case_method_name))
+        Ok(magnus::Ruby::get()
+            .unwrap()
+            .to_symbol(snake_case_method_name))
     }
 
     pub fn stream(&self) -> MagnusResult<ItsiGrpcResponseStream> {
@@ -205,7 +207,7 @@ impl ItsiGrpcCall {
         })
         .map_err(|e: std::io::Error| {
             Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("deflate decompression failed: {}", e),
             )
         })?;
@@ -224,7 +226,7 @@ impl ItsiGrpcCall {
         })
         .map_err(|e: std::io::Error| {
             Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("gzip decompression failed: {}", e),
             )
         })?;
@@ -243,7 +245,7 @@ impl ItsiGrpcCall {
         })
         .map_err(|e| {
             Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("gzip compression failed: {e}"),
             )
         })?;
@@ -262,7 +264,7 @@ impl ItsiGrpcCall {
         })
         .map_err(|e| {
             Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("deflate compression failed: {e}"),
             )
         })?;

data/crates/itsi_server/src/ruby_types/itsi_grpc_response_stream/mod.rs

@@ -59,7 +59,7 @@ impl ItsiGrpcResponseStreamInner {
             .blocking_send(ByteFrame::Data(bytes))
             .map_err(|err| {
                 magnus::Error::new(
-                    magnus::exception::io_error(),
+                    magnus::Ruby::get().unwrap().exception_io_error(),
                     format!("Trying to write to closed stream: {:?}", err),
                 )
             })?;
@@ -80,7 +80,7 @@ impl ItsiGrpcResponseStreamInner {
         let trailer_tx = std::mem::replace(&mut self.trailer_tx, oneshot::channel().0);
         trailer_tx.send(header_map).map_err(|err| {
             magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("Error sending trailers {:?}", err),
             )
         })?;

data/crates/itsi_server/src/ruby_types/itsi_http_request.rs

@@ -6,9 +6,9 @@ use itsi_error::CLIENT_CONNECTION_CLOSED;
 use itsi_rb_helpers::{funcall_no_ret, print_rb_backtrace, HeapValue};
 use itsi_tracing::debug;
 use magnus::{
-    block::{yield_values, Proc},
+    block::Proc,
     error::{ErrorType, Result as MagnusResult},
-    Error, IntoValue, RHash, Symbol,
+    Error, IntoValue, RHash,
 };
 use magnus::{
     value::{LazyId, ReprValue},
@@ -110,20 +110,20 @@ impl ItsiHttpRequest {
                 // when building against Ruby < 3.2...
                 #[cfg(not(ruby_gte_3_2))]
                 {
-                    RHash::new()
+                    magnus::Ruby::get().unwrap().hash_new()
                 }
             };
             for (i, group_name) in re.capture_names().enumerate().skip(1) {
                 if let Some(name) = group_name {
                     if let Some(m) = caps.get(i) {
                         // Insert into the hash: key is the group name, value is the match.
-                        params.aset(Symbol::new(name), m.as_str())?;
+                        params.aset(magnus::Ruby::get().unwrap().to_symbol(name), m.as_str())?;
                     }
                 }
             }
             Ok(params)
         } else {
-            Ok(RHash::new())
+            Ok(magnus::Ruby::get().unwrap().hash_new())
         }
     }
 
@@ -201,7 +201,7 @@ impl ItsiHttpRequest {
                         }
                     },
                     Ok(_) => match receiver.await {
-                        Ok(ResponseFrame::HttpResponse(response)) => Ok(response),
+                        Ok(ResponseFrame::HttpResponse(response)) => Ok(*response),
                         Ok(ResponseFrame::HijackedResponse(response)) => {
                             match response.process_hijacked_response().await {
                                 Ok(result) => Ok(result),
@@ -354,7 +354,10 @@ impl ItsiHttpRequest {
 
     pub(crate) fn each_header(&self) -> MagnusResult<()> {
         self.parts.headers.iter().for_each(|(hn, hv)| {
-            yield_values::<_, Value>((hn.as_str(), hv.to_str().unwrap_or(""))).ok();
+            magnus::Ruby::get()
+                .unwrap()
+                .yield_values::<_, Value>((hn.as_str(), hv.to_str().unwrap_or("")))
+                .ok();
         });
         Ok(())
     }