itsi 0.1.11 → 0.1.12

data/{sandbox/itsi_itsi_file/Itsi.rb → Itsi.rb}

@@ -1,25 +1,24 @@
 # frozen_string_literal: true
-
-env = ENV.fetch('APP_ENV') { ENV.fetch('RACK_ENV', 'development') }
-
 # 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
+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', 3)
+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.
@@ -37,10 +36,17 @@ fiber_scheduler nil
 # require 'rack'
 # run(Rack::Builder.app do
 #   use Rack::CommonLogger
-#   run ->(_env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+#   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
 # end)
-rackup_file 'config.ru'
+# 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"
@@ -58,10 +64,10 @@ rackup_file 'config.ru'
 # bind "unix:///tmp/itsi.sock"
 # bind "tls:///tmp/itsi.secure.sock"
 
-if env == 'development'
-  bind 'http://localhost:3000'
+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"
+  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
@@ -81,7 +87,7 @@ preload true
 # 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 48 * 1024 * 1024
+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.)

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,22 +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|
-          begin
-            system("(cd sandbox/itsi_sandbox_#{sandbox} && bundle exec #{server} #{ARGV[2..]&.join(" ")} )")
-          rescue Interrupt
-            # Suppress the stacktrace and message for Interrupt
-          end
+          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,14 +1,14 @@
-use std::{os::raw::c_void, ptr::null_mut};
+use std::{ffi::c_int, os::raw::c_void, ptr::null_mut};
 
 use magnus::{
-    RArray, Ruby, Thread, Value,
+    ArgList, RArray, Ruby, Thread, Value,
     block::Proc,
-    rb_sys::FromRawValue,
-    value::{LazyId, ReprValue},
+    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;
@@ -193,9 +193,36 @@ 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,41 +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.44.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"
-ring = "0.17.14"
-async-trait = "0.1.87"
-dirs = "6.0.0"
+rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
 regex = "1.11.1"
+reqwest = { version = "0.12.15", features = ["stream"] }
+ring = "0.17.14"
 route-recognizer = "0.3.1"
-fnv = "1.0.7"
+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,126 +1,17 @@
-use body_proxy::itsi_body_proxy::ItsiBodyProxy;
-use magnus::{
-    error::Result, function, method, value::Lazy, Module, Object, RClass, RHash, RModule, Ruby,
+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 regex::{Regex, RegexSet};
-use request::itsi_request::ItsiRequest;
-use response::itsi_response::ItsiResponse;
-use server::{itsi_server::Server, signal::reset_signal_handlers};
+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);
-}
-
-const ROUTES: [&str; 39] = [
-    r"(?-u)^/organisations/(?<organisation_id>\d+)/users/(?<user_id>\d+)$",
-    r"(?-u)^/projects/(?<project_id>\d+)/tasks/(?<task_id>\d+)$",
-    r"(?-u)^/products/(?<product_id>\d+)(?:/reviews/(?<review_id>\d+))?$",
-    r"(?-u)^/orders/(?<order_id>\d+)/items(?:/(?<item_id>\d+))?$",
-    r"(?-u)^/posts/(?<post_id>\d+)/comments(?:/(?<comment_id>\d+))?$",
-    r"(?-u)^/teams/(?<team_id>\d+)(?:/members/(?<member_id>\d+))?$",
-    r"(?-u)^/categories/(?<category_id>\d+)/subcategories(?:/(?<subcategory_id>\d+))?$",
-    r"(?-u)^/departments/(?<department_id>\d+)/employees/(?<employee_id>\d+)$",
-    r"(?-u)^/events/(?<event_id>\d+)(?:/sessions/(?<session_id>\d+))?$",
-    r"(?-u)^/invoices/(?<invoice_id>\d+)/payments(?:/(?<payment_id>\d+))?$",
-    r"(?-u)^/tickets/(?<ticket_id>\d+)(?:/responses/(?<response_id>\d+))?$",
-    r"(?-u)^/forums/(?<forum_id>\d+)(?:/threads/(?<thread_id>\d+))?$",
-    r"(?-u)^/subscriptions/(?<subscription_id>\d+)/plans(?:/(?<plan_id>\d+))?$",
-    r"(?-u)^/profiles/(?<profile_id>\d+)/settings$",
-    r"(?-u)^/organizations/(?<organization_id>\d+)/billing(?:/(?<billing_id>\d+))?$",
-    r"(?-u)^/vendors/(?<vendor_id>\d+)/products(?:/(?<product_id>\d+))?$",
-    r"(?-u)^/courses/(?<course_id>\d+)/modules(?:/(?<module_id>\d+))?$",
-    r"(?-u)^/accounts/(?<account_id>\d+)(?:/transactions/(?<transaction_id>\d+))?$",
-    r"(?-u)^/warehouses/(?<warehouse_id>\d+)/inventory(?:/(?<inventory_id>\d+))?$",
-    r"(?-u)^/campaigns/(?<campaign_id>\d+)/ads(?:/(?<ad_id>\d+))?$",
-    r"(?-u)^/applications/(?<application_id>\d+)/stages(?:/(?<stage_id>\d+))?$",
-    r"(?-u)^/notifications/(?<notification_id>\d+)$",
-    r"(?-u)^/albums/(?<album_id>\d+)/photos(?:/(?<photo_id>\d+))?$",
-    r"(?-u)^/news/(?<news_id>\d+)/articles(?:/(?<article_id>\d+))?$",
-    r"(?-u)^/libraries/(?<library_id>\d+)/books(?:/(?<book_id>\d+))?$",
-    r"(?-u)^/universities/(?<university_id>\d+)/students(?:/(?<student_id>\d+))?$",
-    r"(?-u)^/banks/(?<bank_id>\d+)/branches(?:/(?<branch_id>\d+))?$",
-    r"(?-u)^/vehicles/(?<vehicle_id>\d+)/services(?:/(?<service_id>\d+))?$",
-    r"(?-u)^/hotels/(?<hotel_id>\d+)/rooms(?:/(?<room_id>\d+))?$",
-    r"(?-u)^/doctors/(?<doctor_id>\d+)/appointments(?:/(?<appointment_id>\d+))?$",
-    r"(?-u)^/gyms/(?<gym_id>\d+)/memberships(?:/(?<membership_id>\d+))?$",
-    r"(?-u)^/restaurants/(?<restaurant_id>\d+)/menus(?:/(?<menu_id>\d+))?$",
-    r"(?-u)^/parks/(?<park_id>\d+)/events(?:/(?<event_id>\d+))?$",
-    r"(?-u)^/theaters/(?<theater_id>\d+)/shows(?:/(?<show_id>\d+))?$",
-    r"(?-u)^/museums/(?<museum_id>\d+)/exhibits(?:/(?<exhibit_id>\d+))?$",
-    r"(?-u)^/stadiums/(?<stadium_id>\d+)/games(?:/(?<game_id>\d+))?$",
-    r"(?-u)^/schools/(?<school_id>\d+)/classes(?:/(?<class_id>\d+))?$",
-    r"(?-u)^/clubs/(?<club_id>\d+)/events(?:/(?<event_id>\d+))?$",
-    r"(?-u)^/festivals/(?<festival_id>\d+)/tickets(?:/(?<ticket_id>\d+))?$",
-];
-use std::sync::LazyLock;
-
-static REGEX_SET: LazyLock<RegexSet> = LazyLock::new(|| RegexSet::new(ROUTES).unwrap());
-static REGEXES: LazyLock<Vec<Regex>> =
-    LazyLock::new(|| ROUTES.iter().map(|&r| Regex::new(r).unwrap()).collect());
-
-fn match_route(input: String) -> Result<Option<(usize, Option<RHash>)>> {
-    if let Some(index) = REGEX_SET.matches(&input).iter().next() {
-        let regex = &REGEXES[index];
-        if let Some(captures) = regex.captures(&input) {
-            let params = RHash::with_capacity(captures.len());
-            for name in regex.capture_names().flatten() {
-                if let Some(value) = captures.name(name) {
-                    params.aset(name, value.as_str()).ok();
-                }
-            }
-            return Ok(Some((index, Some(params))));
-        }
-        return Ok(Some((index, None)));
-    }
-    Ok(None)
-}
-
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
     itsi_tracing::init();
@@ -129,34 +20,35 @@ fn init(ruby: &Ruby) -> Result<()> {
         .ok();
 
     let itsi = ruby.get_inner(&ITSI_MODULE);
-    itsi.define_singleton_method("match_route", function!(match_route, 1))?;
     itsi.define_singleton_method("log_debug", function!(log_debug, 1))?;
     itsi.define_singleton_method("log_info", function!(log_info, 1))?;
     itsi.define_singleton_method("log_warn", function!(log_warn, 1))?;
     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))?;
@@ -165,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())
             }
         }
     }