itsi 0.1.9 → 0.1.12

data/Itsi.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+# This is the default Itsi configuration file, installed when you run `itsi init`
+# It contains a sane starting point for configuring your Itsi server.
+# You can use this file in both development and production environments.
+# Most of the options in this file can be overridden by command line options.
+# Check out itsi -h to learn more about the command line options available to you.
+
+env = ENV.fetch("APP_ENV") { ENV.fetch("RACK_ENV", "development") }
+
+# Number of worker processes to spawn
+# If more than 1, Itsi will be booted in Cluster mode
+workers ENV.fetch("ITSI_WORKERS") {
+  require "etc"
+  env == "development" ? 1 : Etc.nprocessors
+}
+
+# Number of threads to spawn per worker process
+# For pure CPU bound applicationss, you'll get the best results keeping this number low
+# Setting a value of 1 is great for superficial benchmarks, but in reality
+# it's better to set this a bit higher to allow expensive requests to get overtaken and minimize head-of-line blocking
+threads ENV.fetch("ITSI_THREADS", 1)
+
+# If your application is IO bound (e.g. performing a lot of proxied HTTP requests, or heavy queries etc)
+# you can see *substantial* benefits from enabling this option.
+# To set this option, pass a string, not a class (as we will not have loaded the class yet)
+# E.g.
+# `fiber_scheduler "Itsi::Scheduler"` - The default fast and light-weight scheduler that comes with Itsi
+# `fiber_scheduler "Async::Scheduler"` - Bring your own scheduler!
+fiber_scheduler nil
+
+# By default Itsi will run the Rack app from config.ru.
+# You can provide an alternative Rack app file name here
+# Or you can inline the app directly inside Itsi.rb.
+# Only one of `run` and `rackup_file` can be used.
+# E.g.
+# require 'rack'
+# run(Rack::Builder.app do
+#   use Rack::CommonLogger
+#   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+# end)
+# rackup_file "config.ru"
+
+watch "*.rb", [%w[bundle exec itsi reload]]
+location "/*" do
+  get "" do |req|
+    req.respond("Hello")
+  end
+end
+# run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+# If you bind to https, without specifying a certificate, Itsi will use a self-signed certificate.
+# The self-signed certificate will use a CA generated for your host and stored inside `ITSI_LOCAL_CA_DIR` (Defaults to ~/.itsi)
+# bind "https://localhost:3000"
+# bind "https://localhost:3000?domains=dev.itsi.fyi"
+#
+# If you want to use let's encrypt to generate you a real certificate you and pass cert=acme and an acme_email address to generate one.
+# bind "https://itsi.fyi?cert=acme&acme_email=admin@itsi.fyi"
+# You can generate certificates for multiple domains at once, by passing a comma-separated list of domains
+# bind "https://0.0.0.0?domains=foo.itsi.fyi,bar.itsi.fyi&cert=acme&acme_email=admin@itsi.fyi"
+#
+# If you already have a certificate you can specify it using the cert and key parameters
+# bind "https://itsi.fyi?cert=/path/to/cert.pem&key=/path/to/key.pem"
+#
+# You can also bind to a unix socket or a tls unix socket. E.g.
+# bind "unix:///tmp/itsi.sock"
+# bind "tls:///tmp/itsi.secure.sock"
+
+if env == "development"
+  bind "http://127.0.0.1:3001"
+else
+  bind "https://0.0.0.0?domains=#{ENV["PRODUCTION_DOMAINS"]}&cert=acme&acme_email=admin@itsi.fyi"
+end
+
+# If you want to preload the application, set preload to true
+# to load the entire rack-app defined in rack_file_name before forking.
+# Alternatively, you can preload just a specific set of gems in a group in your gemfile,
+# by providing the group name here.
+# E.g.
+#
+# preload :preload # Load gems inside the preload group
+# preload false # Don't preload.
+#
+# If you want to be able to perform zero-downtime deploys using a single itsi process,
+# you should disable preloads, so that the application is loaded fresh each time a new worker boots
+preload true
+
+# Set the maximum memory limit for each worker process in bytes
+# When this limit is reached, the worker will be gracefully restarted.
+# Only one worker is restarted at a time to ensure we don't take down
+# all of them at once, if they reach the threshold simultaneously.
+worker_memory_limit 1024 * 1024 * 1024
+
+# You can provide an optional block of code to run, when a worker hits its memory threshold (Use this to send yourself an alert,
+# write metrics to disk etc. etc.)
+after_memory_threshold_reached do |pid|
+  puts "Worker #{pid} has reached its memory threshold and will restart"
+end
+
+# Do clean up of any non-threadsafe resources before forking a new worker here.
+before_fork {}
+
+# Reinitialize any non-threadsafe resources after forking a new worker here.
+after_fork {}
+
+# Shutdown timeout
+# Number of seconds to wait for workers to gracefully shutdown before killing them.
+shutdown_timeout 5
+
+# Set this to false for application environments that require rack.input to be a rewindable body
+# (like Rails). For rack applications that can stream inputs, you can set this to true for a more memory-efficient approach.
+stream_body false
+
+# OOB GC responses threshold
+# Specifies how frequently OOB gc should be triggered during periods where there is a gap in queued requests.
+# Setting this too low can substantially worsen performance
+oob_gc_responses_threshold 512
+
+# Log level
+# Set this to one of the following values: debug, info, warn, error, fatal
+# Can also be set using the ITSI_LOG environment variable
+log_level :info
+
+# Log Format
+# Set this to be either :ansi or :json. If you leave it blank Itsi will try
+# and auto-detect the format based on the TTY environment.
+log_format :auto

data/Rakefile

@@ -34,6 +34,7 @@ GEMS.each do |gem|
 
     SHARED_TASKS.each do |task|
       task task do
+        Rake::Task[:sync_crates].invoke
         sh "cd #{gem[:dir]} && rake #{task}"
       end
     end
@@ -57,6 +58,8 @@ task :sync_crates do
   GEMS.each do |gem_info|
     Dir.chdir('crates') do
       to_sync = Dir['*'].each do |to_sync|
+        next unless File.directory?(to_sync)
+
         system("rsync -q -av #{to_sync}/ ../#{gem_info[:dir]}/ext/#{to_sync} --delete")
         system("cp ../Cargo.lock ../#{gem_info[:dir]}/Cargo.lock")
       end
@@ -77,19 +80,20 @@ task :build_all do
 end
 
 task :test_env_up do
-  system("terraform -chdir=sandbox/deploy apply")
+  system('terraform -chdir=sandbox/deploy apply')
 end
 
 task :test_env_down do
-  system("terraform -chdir=sandbox/deploy destroy")
+  system('terraform -chdir=sandbox/deploy destroy')
 end
-
 %i[itsi puma iodine falcon unicorn].each do |server|
   namespace server do
     %i[hanami roda async rack rack_lint rails sinatra].each do |sandbox|
       namespace sandbox do
         task :serve do |args|
-          sh "(cd sandbox/itsi_sandbox_#{sandbox} && bundle exec #{server} #{ARGV[2..]&.join(" ")} )"
+          system("(cd sandbox/itsi_sandbox_#{sandbox} && bundle exec #{server} #{ARGV[2..]&.join(' ')} )")
+        rescue Interrupt
+          # Suppress the stacktrace and message for Interrupt
         end
       end
     end

data/crates/itsi_error/src/lib.rs

@@ -22,3 +22,12 @@ pub enum ItsiError {
     #[error("Pass")]
     Pass(),
 }
+
+impl ItsiError {
+    pub fn default(error: impl Send + Sync + 'static + std::fmt::Display) -> Self {
+        ItsiError::InvalidInput(format!("{}", error))
+    }
+}
+
+unsafe impl Send for ItsiError {}
+unsafe impl Sync for ItsiError {}

data/crates/itsi_rb_helpers/Cargo.toml

@@ -8,3 +8,4 @@ cfg-if = "1.0.0"
 magnus = { version = "0.7.1", features = ["rb-sys", "bytes"] }
 nix = "0.29.0"
 rb-sys = "0.9.105"
+serde = "1.0.219"

data/crates/itsi_rb_helpers/src/heap_value.rs

@@ -23,6 +23,24 @@ where
     }
 }
 
+impl<T> HeapValue<T>
+where
+    T: ReprValue,
+{
+    pub fn into_inner(self) -> T {
+        *self.0
+    }
+}
+
+impl<T> HeapValue<T>
+where
+    T: ReprValue,
+{
+    pub fn cloned(&self) -> T {
+        *self.0
+    }
+}
+
 impl<T> Deref for HeapValue<T>
 where
     T: ReprValue,

data/crates/itsi_rb_helpers/src/lib.rs

@@ -1,13 +1,14 @@
-use std::{os::raw::c_void, ptr::null_mut, sync::Arc};
+use std::{ffi::c_int, os::raw::c_void, ptr::null_mut};
 
 use magnus::{
-    RArray, Ruby, Thread, Value,
-    rb_sys::FromRawValue,
-    value::{LazyId, ReprValue},
+    ArgList, RArray, Ruby, Thread, Value,
+    block::Proc,
+    rb_sys::{AsRawId, FromRawValue, protect},
+    value::{IntoId, LazyId, ReprValue},
 };
 use rb_sys::{
-    rb_thread_call_with_gvl, rb_thread_call_without_gvl, rb_thread_create, rb_thread_schedule,
-    rb_thread_wakeup,
+    VALUE, rb_funcallv, rb_thread_call_with_gvl, rb_thread_call_without_gvl, rb_thread_create,
+    rb_thread_schedule, rb_thread_wakeup,
 };
 
 mod heap_value;
@@ -17,6 +18,7 @@ static ID_LIST: LazyId = LazyId::new("list");
 static ID_EQ: LazyId = LazyId::new("==");
 static ID_ALIVE: LazyId = LazyId::new("alive?");
 static ID_THREAD_VARIABLE_GET: LazyId = LazyId::new("thread_variable_get");
+static ID_BACKTRACE: LazyId = LazyId::new("backtrace");
 
 pub fn schedule_thread() {
     unsafe {
@@ -120,20 +122,30 @@ where
     *result_box
 }
 
-pub fn fork(after_fork: Arc<Option<impl Fn()>>) -> Option<i32> {
+pub fn fork(after_fork: Option<HeapValue<Proc>>) -> Option<i32> {
     let ruby = Ruby::get().unwrap();
     let fork_result = ruby
         .module_kernel()
         .funcall::<_, _, Option<i32>>(*ID_FORK, ())
         .unwrap();
     if fork_result.is_none() {
-        if let Some(f) = &*after_fork {
-            f()
+        if let Some(proc) = after_fork {
+            call_proc_and_log_errors(proc)
         }
     }
     fork_result
 }
 
+pub fn call_proc_and_log_errors(proc: HeapValue<Proc>) {
+    if let Err(e) = proc.call::<_, Value>(()) {
+        if let Some(value) = e.value() {
+            print_rb_backtrace(value);
+        } else {
+            eprintln!("Error occurred {:?}", e);
+        }
+    }
+}
+
 pub fn kill_threads<T>(threads: Vec<T>)
 where
     T: ReprValue,
@@ -176,3 +188,41 @@ pub fn terminate_non_fork_safe_threads() {
 
     kill_threads(non_fork_safe_threads);
 }
+
+pub fn print_rb_backtrace(rb_err: Value) {
+    let backtrace = rb_err
+        .funcall::<_, _, Vec<String>>(*ID_BACKTRACE, ())
+        .unwrap_or_default();
+    let rust_backtrace = std::backtrace::Backtrace::capture().to_string();
+    eprintln!("Ruby exception {:?}", rb_err);
+    for line in backtrace {
+        eprintln!("{}", line);
+    }
+    for line in rust_backtrace.lines() {
+        eprintln!("{}", line);
+    }
+}
+
+pub fn funcall_no_ret<T, M, A>(target: T, method: M, args: A) -> magnus::error::Result<()>
+where
+    T: ReprValue,
+    M: IntoId,
+    A: ArgList,
+{
+    protect(|| {
+        let handle = Ruby::get().unwrap();
+        let method = method.into_id_with(&handle);
+        let args = args.into_arg_list_with(&handle);
+        let slice = args.as_ref();
+        unsafe {
+            rb_funcallv(
+                target.as_rb_value(),
+                method.as_raw(),
+                slice.len() as c_int,
+                slice.as_ptr() as *const VALUE,
+            );
+        }
+        0
+    })?;
+    Ok(())
+}

data/crates/itsi_server/Cargo.toml

@@ -10,38 +10,80 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
-itsi_tracing = { path = "../itsi_tracing" }
-itsi_rb_helpers = { path = "../itsi_rb_helpers" }
-itsi_error = { path = "../itsi_error" }
-socket2 = "0.5.8"
-parking_lot = "0.12.3"
-rustls-pemfile = "2.2.0"
-tokio-rustls = "0.26.2"
-bytes = "1.3"
-tokio-rustls-acme = "0.6.0"
-rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
+async-compression = { version = "0.4.21", features = [
+  "tokio",
+  "zstd",
+  "brotli",
+  "deflate",
+  "gzip",
+] }
+async-channel = "2.3.1"
+async-trait = "0.1.87"
 base64 = "0.22.1"
+bytes = "1.3"
+chrono = "0.4.35"
+crossbeam = "0.8.4"
+dashmap = "6.1.0"
+derive_more = { version = "2.0.1", features = ["debug"] }
+dirs = "6.0.0"
+either = "1.15.0"
+fnv = "1.0.7"
+fs2 = "0.4.3"
+futures = "0.3.31"
+globset = "0.4.16"
+hmac = "0.12.1"
+http = "1.3.1"
 http-body-util = "0.1.2"
+httpdate = "1.0.3"
+httparse = "1.10.1"
 hyper = { version = "1.5.0", features = ["full", "server", "http1", "http2"] }
-tokio = { version = "1", features = ["full"] }
+hyper-staticfile = "0.10.1"
 hyper-util = { version = "0.1.10", features = ["full"] }
-derive_more = { version = "2.0.1", features = ["debug"] }
-http = "1.3.1"
-crossbeam = "0.8.4"
-futures = "0.3.31"
-nix = { version = "0.29.0", features = ["socket", "uio", "signal"] }
+itsi_error = { path = "../itsi_error" }
+itsi_rb_helpers = { path = "../itsi_rb_helpers" }
+itsi_tracing = { path = "../itsi_tracing" }
+jwt-simple = "0.12.12"
+magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
+moka = { version = "0.12.10", features = ["sync"] }
+notify = { version = "8.0.0" }
+nix = { version = "0.29.0", features = [
+  "socket",
+  "uio",
+  "signal",
+  "fs",
+  "process",
+] }
+num_cpus = "1.16.0"
+parking_lot = "0.12.3"
 pin-project = "1.1.9"
+rand = "0.9.0"
 rb-sys = "0.9.111"
-tracing = "0.1.41"
-tokio-util = "0.7.13"
-tokio-stream = "0.1.17"
-httparse = "1.10.1"
-async-channel = "2.3.1"
-tempfile = "3.18.0"
-sysinfo = "0.33.1"
-rustls = "0.23.23"
-fs2 = "0.4.3"
+rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
+regex = "1.11.1"
+reqwest = { version = "0.12.15", features = ["stream"] }
 ring = "0.17.14"
-async-trait = "0.1.87"
-dirs = "6.0.0"
+route-recognizer = "0.3.1"
+redis = { version = "0.29.2", features = [
+  "tokio-comp",
+  "r2d2",
+  "tokio-rustls-comp",
+  "connection-manager",
+] }
+rustls = "0.23.23"
+rustls-pemfile = "2.2.0"
+serde = "1.0.219"
+serde_json = "1.0.140"
+serde_magnus = "0.9.0"
+sha2 = "0.10.8"
+socket2 = "0.5.8"
+sysinfo = "0.33.1"
+tempfile = "3.18.0"
+tokio = { version = "1.44.1", features = ["full"] }
+tokio-rustls = "0.26.2"
+tokio-rustls-acme = "0.6.0"
+tokio-stream = "0.1.17"
+tokio-util = "0.7.13"
+tracing = "0.1.41"
+url = "2.5.4"
+uuid = "1.16.0"
+md5 = "0.7.0"

data/crates/itsi_server/src/lib.rs

@@ -1,59 +1,17 @@
-use body_proxy::itsi_body_proxy::ItsiBodyProxy;
-use magnus::{error::Result, function, method, value::Lazy, Module, Object, RClass, RModule, Ruby};
-use request::itsi_request::ItsiRequest;
-use response::itsi_response::ItsiResponse;
-use server::{itsi_server::Server, signal::reset_signal_handlers};
+use magnus::{error::Result, function, method, Module, Object, Ruby};
+use ruby_types::{
+    itsi_body_proxy::ItsiBodyProxy, itsi_grpc_request::ItsiGrpcRequest,
+    itsi_grpc_stream::ItsiGrpcStream, itsi_http_request::ItsiHttpRequest,
+    itsi_http_response::ItsiHttpResponse, itsi_server::ItsiServer, ITSI_BODY_PROXY,
+    ITSI_GRPC_REQUEST, ITSI_GRPC_RESPONSE, ITSI_GRPC_STREAM, ITSI_MODULE, ITSI_REQUEST,
+    ITSI_RESPONSE, ITSI_SERVER,
+};
+use server::signal::reset_signal_handlers;
 use tracing::*;
-
-pub mod body_proxy;
 pub mod env;
-pub mod request;
-pub mod response;
+pub mod ruby_types;
 pub mod server;
 
-pub static ITSI_MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("Itsi").unwrap());
-pub static ITSI_SERVER: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Server", ruby.class_object())
-        .unwrap()
-});
-pub static ITSI_REQUEST: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Request", ruby.class_object())
-        .unwrap()
-});
-
-pub static ITSI_RESPONSE: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Response", ruby.class_object())
-        .unwrap()
-});
-
-pub static ITSI_BODY_PROXY: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("BodyProxy", ruby.class_object())
-        .unwrap()
-});
-
-pub static ITSI_SERVER_SCHEDULER_TASK: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("ServerSchedulerTask", ruby.class_object())
-        .unwrap()
-});
-
-pub fn log_debug(msg: String) {
-    debug!(msg);
-}
-pub fn log_info(msg: String) {
-    info!(msg);
-}
-pub fn log_warn(msg: String) {
-    warn!(msg);
-}
-pub fn log_error(msg: String) {
-    error!(msg);
-}
-
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
     itsi_tracing::init();
@@ -68,27 +26,29 @@ fn init(ruby: &Ruby) -> Result<()> {
     itsi.define_singleton_method("log_error", function!(log_error, 1))?;
 
     let server = ruby.get_inner(&ITSI_SERVER);
-    server.define_singleton_method("new", function!(Server::new, -1))?;
+    server.define_singleton_method("new", function!(ItsiServer::new, 3))?;
     server.define_singleton_method("reset_signal_handlers", function!(reset_signal_handlers, 0))?;
-    server.define_method("start", method!(Server::start, 0))?;
-    server.define_method("stop", method!(Server::stop, 0))?;
+    server.define_method("start", method!(ItsiServer::start, 0))?;
+    server.define_method("stop", method!(ItsiServer::stop, 0))?;
 
     let request = ruby.get_inner(&ITSI_REQUEST);
-    request.define_method("path", method!(ItsiRequest::path, 0))?;
-    request.define_method("script_name", method!(ItsiRequest::script_name, 0))?;
-    request.define_method("query_string", method!(ItsiRequest::query_string, 0))?;
-    request.define_method("method", method!(ItsiRequest::method, 0))?;
-    request.define_method("version", method!(ItsiRequest::version, 0))?;
-    request.define_method("rack_protocol", method!(ItsiRequest::rack_protocol, 0))?;
-    request.define_method("host", method!(ItsiRequest::host, 0))?;
-    request.define_method("headers", method!(ItsiRequest::headers, 0))?;
-    request.define_method("scheme", method!(ItsiRequest::scheme, 0))?;
-    request.define_method("remote_addr", method!(ItsiRequest::remote_addr, 0))?;
-    request.define_method("port", method!(ItsiRequest::port, 0))?;
-    request.define_method("body", method!(ItsiRequest::body, 0))?;
-    request.define_method("response", method!(ItsiRequest::response, 0))?;
-    request.define_method("json?", method!(ItsiRequest::is_json, 0))?;
-    request.define_method("html?", method!(ItsiRequest::is_html, 0))?;
+    request.define_method("path", method!(ItsiHttpRequest::path, 0))?;
+    request.define_method("script_name", method!(ItsiHttpRequest::script_name, 0))?;
+    request.define_method("query_string", method!(ItsiHttpRequest::query_string, 0))?;
+    request.define_method("method", method!(ItsiHttpRequest::method, 0))?;
+    request.define_method("version", method!(ItsiHttpRequest::version, 0))?;
+    request.define_method("rack_protocol", method!(ItsiHttpRequest::rack_protocol, 0))?;
+    request.define_method("host", method!(ItsiHttpRequest::host, 0))?;
+    request.define_method("headers", method!(ItsiHttpRequest::headers, 0))?;
+    request.define_method("header", method!(ItsiHttpRequest::header, 1))?;
+    request.define_method("[]", method!(ItsiHttpRequest::header, 1))?;
+    request.define_method("scheme", method!(ItsiHttpRequest::scheme, 0))?;
+    request.define_method("remote_addr", method!(ItsiHttpRequest::remote_addr, 0))?;
+    request.define_method("port", method!(ItsiHttpRequest::port, 0))?;
+    request.define_method("body", method!(ItsiHttpRequest::body, 0))?;
+    request.define_method("response", method!(ItsiHttpRequest::response, 0))?;
+    request.define_method("json?", method!(ItsiHttpRequest::is_json, 0))?;
+    request.define_method("html?", method!(ItsiHttpRequest::is_html, 0))?;
 
     let body_proxy = ruby.get_inner(&ITSI_BODY_PROXY);
     body_proxy.define_method("gets", method!(ItsiBodyProxy::gets, 0))?;
@@ -97,16 +57,56 @@ fn init(ruby: &Ruby) -> Result<()> {
     body_proxy.define_method("close", method!(ItsiBodyProxy::close, 0))?;
 
     let response = ruby.get_inner(&ITSI_RESPONSE);
-    response.define_method("add_header", method!(ItsiResponse::add_header, 2))?;
-    response.define_method("status=", method!(ItsiResponse::set_status, 1))?;
-    response.define_method("send_frame", method!(ItsiResponse::send_frame, 1))?;
-    response.define_method("send_and_close", method!(ItsiResponse::send_and_close, 1))?;
-    response.define_method("close_write", method!(ItsiResponse::close_write, 0))?;
-    response.define_method("close_read", method!(ItsiResponse::close_read, 0))?;
-    response.define_method("close", method!(ItsiResponse::close, 0))?;
-    response.define_method("hijack", method!(ItsiResponse::hijack, 1))?;
-    response.define_method("json?", method!(ItsiResponse::is_json, 0))?;
-    response.define_method("html?", method!(ItsiResponse::is_html, 0))?;
+    response.define_method("[]=", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method("add_header", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method("add_headers", method!(ItsiHttpResponse::add_headers, 1))?;
+    response.define_method("status=", method!(ItsiHttpResponse::set_status, 1))?;
+    response.define_method("send_frame", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("<<", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("write", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("read", method!(ItsiHttpResponse::recv_frame, 0))?;
+    response.define_method(
+        "send_and_close",
+        method!(ItsiHttpResponse::send_and_close, 1),
+    )?;
+    response.define_method("close_write", method!(ItsiHttpResponse::close_write, 0))?;
+    response.define_method("close_read", method!(ItsiHttpResponse::close_read, 0))?;
+    response.define_method("close", method!(ItsiHttpResponse::close, 0))?;
+    response.define_method("hijack", method!(ItsiHttpResponse::hijack, 1))?;
+    response.define_method("json?", method!(ItsiHttpResponse::is_json, 0))?;
+    response.define_method("html?", method!(ItsiHttpResponse::is_html, 0))?;
+
+    let grpc_request = ruby.get_inner(&ITSI_GRPC_REQUEST);
+
+    grpc_request.define_method("service_name", method!(ItsiGrpcRequest::service_name, 0))?;
+    grpc_request.define_method("method_name", method!(ItsiGrpcRequest::method_name, 0))?;
+    grpc_request.define_method("stream", method!(ItsiGrpcRequest::stream, 0))?;
+    grpc_request.define_method("json?", method!(ItsiGrpcRequest::is_json, 0))?;
+    grpc_request.define_method(
+        "content_type",
+        method!(ItsiGrpcRequest::content_type_str, 0),
+    )?;
+
+    let grpc_stream = ruby.get_inner(&ITSI_GRPC_STREAM);
+    grpc_stream.define_method("read", method!(ItsiGrpcStream::read, 1))?;
+    grpc_stream.define_method("write", method!(ItsiGrpcStream::write, 1))?;
+    grpc_stream.define_method("flush", method!(ItsiGrpcStream::flush, 0))?;
+    grpc_stream.define_method("send_trailers", method!(ItsiGrpcStream::send_trailers, 1))?;
+
+    let _grpc_response = ruby.get_inner(&ITSI_GRPC_RESPONSE);
 
     Ok(())
 }
+
+pub fn log_debug(msg: String) {
+    debug!(msg);
+}
+pub fn log_info(msg: String) {
+    info!(msg);
+}
+pub fn log_warn(msg: String) {
+    warn!(msg);
+}
+pub fn log_error(msg: String) {
+    error!(msg);
+}

data/crates/itsi_server/src/{body_proxy → ruby_types/itsi_body_proxy}/big_bytes.rs

@@ -6,7 +6,7 @@ use tempfile::NamedTempFile;
 
 const THRESHOLD: usize = 1024 * 1024; // 1 MB
 
-/// An container that holds data in memory if it’s small, or in a temporary file on disk if it exceeds THRESHOLD.
+/// A container that will hold data in memory if it’s small, or in a temporary file on disk if it exceeds THRESHOLD.
 /// Used for providing Rack input data.
 pub enum BigBytes {
     InMemory(Vec<u8>),
@@ -27,7 +27,7 @@ impl BigBytes {
         BigBytes::InMemory(Vec::new())
     }
 
-    /// Reads the entire contents that have been written.
+    /// Returns either the raw bytes, or the file path of the BigBytes
     ///
     /// - If stored in memory, returns a clone of the bytes.
     /// - If stored on disk, returns the file path of the temporary file.
@@ -42,17 +42,22 @@ impl BigBytes {
         }
     }
 
-    pub fn as_value(&self) -> Value {
+    /// Turn this into a value that can be used in Ruby.
+    pub fn as_value(&self) -> Option<Value> {
         match self {
             BigBytes::InMemory(bytes) => {
                 let bytes = Bytes::from(bytes.to_owned());
-                bytes.into_value()
+                if bytes.is_empty() {
+                    None
+                } else {
+                    Some(bytes.into_value())
+                }
             }
             BigBytes::OnDisk(path) => {
                 let ruby = Ruby::get().unwrap();
                 let rarray = ruby.ary_new();
                 rarray.push(path.path().to_str().unwrap().into_value()).ok();
-                rarray.into_value()
+                Some(rarray.into_value())
             }
         }
     }